Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 4912:a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
Summary: Revamp of the mechanism that chooses old regions for inclusion in the CSet. It simplifies the code and introduces min and max bounds on the number of old regions added to the CSet at each mixed GC to avoid pathological cases. It also ensures that when we do a mixed GC we'll always find old regions to add to the CSet (i.e., it eliminates the case where a mixed GC will collect no old regions which can happen today).
Reviewed-by: johnc, brutisso
author | tonyp |
---|---|
date | Wed, 15 Feb 2012 13:06:53 -0500 |
parents | eff609af17d7 |
children | 21595f05bc93 |
rev | line source |
---|---|
342 | 1 /* |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
342 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
21 * questions. |
342 | 22 * |
23 */ | |
24 | |
1972 | 25 #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" | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
31 #include "gc_implementation/g1/g1ErgoVerbose.hpp" |
1972 | 32 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
33 #include "gc_implementation/shared/gcPolicyCounters.hpp" | |
34 #include "runtime/arguments.hpp" | |
35 #include "runtime/java.hpp" | |
36 #include "runtime/mutexLocker.hpp" | |
37 #include "utilities/debug.hpp" | |
342 | 38 |
39 // Different defaults for different number of GC threads | |
40 // They were chosen by running GCOld and SPECjbb on debris with different | |
41 // numbers of GC threads and choosing them based on the results | |
42 | |
43 // all the same | |
44 static double rs_length_diff_defaults[] = { | |
45 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 | |
46 }; | |
47 | |
48 static double cost_per_card_ms_defaults[] = { | |
49 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015 | |
50 }; | |
51 | |
52 // all the same | |
4710 | 53 static double young_cards_per_entry_ratio_defaults[] = { |
342 | 54 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 |
55 }; | |
56 | |
57 static double cost_per_entry_ms_defaults[] = { | |
58 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005 | |
59 }; | |
60 | |
61 static double cost_per_byte_ms_defaults[] = { | |
62 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009 | |
63 }; | |
64 | |
65 // these should be pretty consistent | |
66 static double constant_other_time_ms_defaults[] = { | |
67 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 | |
68 }; | |
69 | |
70 | |
71 static double young_other_cost_per_region_ms_defaults[] = { | |
72 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1 | |
73 }; | |
74 | |
75 static double non_young_other_cost_per_region_ms_defaults[] = { | |
76 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 | |
77 }; | |
78 | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
79 // Help class for avoiding interleaved logging |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
80 class LineBuffer: public StackObj { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
81 |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
82 private: |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
83 static const int BUFFER_LEN = 1024; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
84 static const int INDENT_CHARS = 3; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
85 char _buffer[BUFFER_LEN]; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
86 int _indent_level; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
87 int _cur; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
88 |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
89 void vappend(const char* format, va_list ap) { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
90 int res = vsnprintf(&_buffer[_cur], BUFFER_LEN - _cur, format, ap); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
91 if (res != -1) { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
92 _cur += res; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
93 } else { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
94 DEBUG_ONLY(warning("buffer too small in LineBuffer");) |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
95 _buffer[BUFFER_LEN -1] = 0; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
96 _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
|
97 } |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
98 } |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
99 |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
100 public: |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
101 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
|
102 for (; (_cur < BUFFER_LEN && _cur < (_indent_level * INDENT_CHARS)); _cur++) { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
103 _buffer[_cur] = ' '; |
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 } |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
106 |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
107 #ifndef PRODUCT |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
108 ~LineBuffer() { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
109 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
|
110 } |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
111 #endif |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
112 |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
113 void append(const char* format, ...) { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
114 va_list ap; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
115 va_start(ap, format); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
116 vappend(format, ap); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
117 va_end(ap); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
118 } |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
119 |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
120 void append_and_print_cr(const char* format, ...) { |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
121 va_list ap; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
122 va_start(ap, format); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
123 vappend(format, ap); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
124 va_end(ap); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
125 gclog_or_tty->print_cr("%s", _buffer); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
126 _cur = _indent_level * INDENT_CHARS; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
127 } |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
128 }; |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
129 |
342 | 130 G1CollectorPolicy::G1CollectorPolicy() : |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
131 _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
|
132 ? ParallelGCThreads : 1), |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
133 |
342 | 134 _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
135 _all_pause_times_ms(new NumberSeq()), | |
136 _stop_world_start(0.0), | |
137 _all_stop_world_times_ms(new NumberSeq()), | |
138 _all_yield_times_ms(new NumberSeq()), | |
139 | |
677 | 140 _summary(new Summary()), |
342 | 141 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
142 _cur_clear_ct_time_ms(0.0), |
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
143 _mark_closure_time_ms(0.0), |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
144 _root_region_scan_wait_time_ms(0.0), |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
145 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
146 _cur_ref_proc_time_ms(0.0), |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
147 _cur_ref_enq_time_ms(0.0), |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
148 |
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
149 #ifndef PRODUCT |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
150 _min_clear_cc_time_ms(-1.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
151 _max_clear_cc_time_ms(-1.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
152 _cur_clear_cc_time_ms(0.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
153 _cum_clear_cc_time_ms(0.0), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
154 _num_cc_clears(0L), |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
155 #endif |
342 | 156 |
157 _aux_num(10), | |
158 _all_aux_times_ms(new NumberSeq[_aux_num]), | |
159 _cur_aux_start_times_ms(new double[_aux_num]), | |
160 _cur_aux_times_ms(new double[_aux_num]), | |
161 _cur_aux_times_set(new bool[_aux_num]), | |
162 | |
163 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
164 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
165 | |
166 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
167 _prev_collection_pause_end_ms(0.0), | |
168 _pending_card_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
169 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
170 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
4710 | 171 _young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), |
172 _mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), | |
342 | 173 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
4710 | 174 _mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
342 | 175 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
176 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)), | |
177 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
178 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
179 _non_young_other_cost_per_region_ms_seq( | |
180 new TruncatedSeq(TruncatedSeqLength)), | |
181 | |
182 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)), | |
183 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)), | |
184 | |
751 | 185 _pause_time_target_ms((double) MaxGCPauseMillis), |
342 | 186 |
4710 | 187 _gcs_are_young(true), |
188 _young_pause_num(0), | |
189 _mixed_pause_num(0), | |
342 | 190 |
191 _during_marking(false), | |
192 _in_marking_window(false), | |
193 _in_marking_window_im(false), | |
194 | |
195 _known_garbage_ratio(0.0), | |
196 _known_garbage_bytes(0), | |
197 | |
198 _young_gc_eff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
199 | |
4710 | 200 _recent_prev_end_times_for_all_gcs_sec( |
201 new TruncatedSeq(NumPrevPausesForHeuristics)), | |
342 | 202 |
203 _recent_avg_pause_time_ratio(0.0), | |
204 | |
205 _all_full_gc_times_ms(new NumberSeq()), | |
206 | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
207 _initiate_conc_mark_if_possible(false), |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
208 _during_initial_mark_pause(false), |
4710 | 209 _last_young_gc(false), |
210 _last_gc_was_young(false), | |
342 | 211 |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
212 _eden_bytes_before_gc(0), |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
213 _survivor_bytes_before_gc(0), |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
214 _capacity_before_gc(0), |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
215 |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
216 _eden_cset_region_length(0), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
217 _survivor_cset_region_length(0), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
218 _old_cset_region_length(0), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
219 |
342 | 220 _collection_set(NULL), |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
221 _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
|
222 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
223 // Incremental CSet attributes |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
224 _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
|
225 _inc_cset_head(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
226 _inc_cset_tail(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
227 _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
|
228 _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
|
229 _inc_cset_recorded_rs_lengths(0), |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
230 _inc_cset_recorded_rs_lengths_diffs(0), |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
231 _inc_cset_predicted_elapsed_time_ms(0.0), |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
232 _inc_cset_predicted_elapsed_time_ms_diffs(0.0), |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
233 |
342 | 234 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away |
235 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
236 #endif // _MSC_VER | |
237 | |
238 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived", | |
239 G1YoungSurvRateNumRegionsSummary)), | |
240 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor", | |
545 | 241 G1YoungSurvRateNumRegionsSummary)), |
342 | 242 // add here any more surv rate groups |
545 | 243 _recorded_survivor_regions(0), |
244 _recorded_survivor_head(NULL), | |
245 _recorded_survivor_tail(NULL), | |
1356 | 246 _survivors_age_table(true), |
247 | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
248 _gc_overhead_perc(0.0) { |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
249 |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
250 // 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
|
251 // 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
|
252 // so it's done as soon as possible. |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
253 HeapRegion::setup_heap_region_size(Arguments::min_heap_size()); |
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1111
diff
changeset
|
254 HeapRegionRemSet::setup_remset_size(); |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
255 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
256 G1ErgoVerbose::initialize(); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
257 if (PrintAdaptiveSizePolicy) { |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
258 // Currently, we only use a single switch for all the heuristics. |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
259 G1ErgoVerbose::set_enabled(true); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
260 // Given that we don't currently have a verboseness level |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
261 // parameter, we'll hardcode this to high. This can be easily |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
262 // changed in the future. |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
263 G1ErgoVerbose::set_level(ErgoHigh); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
264 } else { |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
265 G1ErgoVerbose::set_enabled(false); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
266 } |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
267 |
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
268 // Verify PLAB sizes |
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3982
diff
changeset
|
269 const size_t region_size = HeapRegion::GrainWords; |
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
270 if (YoungPLABSize > region_size || OldPLABSize > region_size) { |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
271 char buffer[128]; |
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3982
diff
changeset
|
272 jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT, |
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
273 OldPLABSize > region_size ? "Old" : "Young", region_size); |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
274 vm_exit_during_initialization(buffer); |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
275 } |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
276 |
342 | 277 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); |
278 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; | |
279 | |
1611 | 280 _par_last_gc_worker_start_times_ms = new double[_parallel_gc_threads]; |
342 | 281 _par_last_ext_root_scan_times_ms = new double[_parallel_gc_threads]; |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
282 _par_last_satb_filtering_times_ms = new double[_parallel_gc_threads]; |
342 | 283 |
284 _par_last_update_rs_times_ms = new double[_parallel_gc_threads]; | |
285 _par_last_update_rs_processed_buffers = new double[_parallel_gc_threads]; | |
286 | |
287 _par_last_scan_rs_times_ms = new double[_parallel_gc_threads]; | |
288 | |
289 _par_last_obj_copy_times_ms = new double[_parallel_gc_threads]; | |
290 | |
291 _par_last_termination_times_ms = new double[_parallel_gc_threads]; | |
1611 | 292 _par_last_termination_attempts = new double[_parallel_gc_threads]; |
293 _par_last_gc_worker_end_times_ms = new double[_parallel_gc_threads]; | |
2430 | 294 _par_last_gc_worker_times_ms = new double[_parallel_gc_threads]; |
4023 | 295 _par_last_gc_worker_other_times_ms = new double[_parallel_gc_threads]; |
342 | 296 |
297 int index; | |
298 if (ParallelGCThreads == 0) | |
299 index = 0; | |
300 else if (ParallelGCThreads > 8) | |
301 index = 7; | |
302 else | |
303 index = ParallelGCThreads - 1; | |
304 | |
305 _pending_card_diff_seq->add(0.0); | |
306 _rs_length_diff_seq->add(rs_length_diff_defaults[index]); | |
307 _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]); | |
4710 | 308 _young_cards_per_entry_ratio_seq->add( |
309 young_cards_per_entry_ratio_defaults[index]); | |
342 | 310 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]); |
311 _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]); | |
312 _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]); | |
313 _young_other_cost_per_region_ms_seq->add( | |
314 young_other_cost_per_region_ms_defaults[index]); | |
315 _non_young_other_cost_per_region_ms_seq->add( | |
316 non_young_other_cost_per_region_ms_defaults[index]); | |
317 | |
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
|
318 // 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
|
319 // 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
|
320 // 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
|
321 // 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
|
322 // 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
|
323 // 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
|
324 // 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
|
325 // 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
|
326 // 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
|
327 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
328 // 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
|
329 // 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
|
330 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
|
331 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
|
332 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
|
333 "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
|
334 } |
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
|
335 } |
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
|
336 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
|
337 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
|
338 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
|
339 "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
|
340 } |
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 } |
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 |
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 // 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
|
344 // 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
|
345 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
|
346 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
|
347 // 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
|
348 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
|
349 } 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
|
350 // 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
|
351 // 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
|
352 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
|
353 "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
|
354 } |
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 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
356 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
357 // 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
|
358 // 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
|
359 // 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
|
360 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
|
361 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
|
362 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
363 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
364 // 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
|
365 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
|
366 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
|
367 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
|
368 "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
|
369 "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
|
370 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
|
371 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
|
372 } |
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 |
751 | 374 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
|
375 double time_slice = (double) GCPauseIntervalMillis / 1000.0; |
342 | 376 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time); |
751 | 377 _sigma = (double) G1ConfidencePercent / 100.0; |
342 | 378 |
379 // start conservatively (around 50ms is about right) | |
380 _concurrent_mark_remark_times_ms->add(0.05); | |
381 _concurrent_mark_cleanup_times_ms->add(0.20); | |
382 _tenuring_threshold = MaxTenuringThreshold; | |
3868
ae73da50be4b
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
3867
diff
changeset
|
383 // _max_survivor_regions will be calculated by |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
384 // update_young_list_target_length() during initialization. |
3868
ae73da50be4b
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
3867
diff
changeset
|
385 _max_survivor_regions = 0; |
545 | 386 |
1356 | 387 assert(GCTimeRatio > 0, |
388 "we should have set it to a default value set_g1_gc_flags() " | |
389 "if a user set it to 0"); | |
390 _gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio)); | |
391 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
392 uintx reserve_perc = G1ReservePercent; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
393 // Put an artificial ceiling on this so that it's not set to a silly value. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
394 if (reserve_perc > 50) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
395 reserve_perc = 50; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
396 warning("G1ReservePercent is set to a value that is too large, " |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
397 "it's been updated to %u", reserve_perc); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
398 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
399 _reserve_factor = (double) reserve_perc / 100.0; |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
400 // This will be set when the heap is expanded |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
401 // for the first time during initialization. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
402 _reserve_regions = 0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
403 |
342 | 404 initialize_all(); |
4013 | 405 _collectionSetChooser = new CollectionSetChooser(); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
406 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags |
342 | 407 } |
408 | |
409 void G1CollectorPolicy::initialize_flags() { | |
410 set_min_alignment(HeapRegion::GrainBytes); | |
411 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
|
412 if (SurvivorRatio < 1) { |
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
413 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
|
414 } |
342 | 415 CollectorPolicy::initialize_flags(); |
416 } | |
417 | |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
418 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
419 assert(G1DefaultMinNewGenPercent <= G1DefaultMaxNewGenPercent, "Min larger than max"); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
420 assert(G1DefaultMinNewGenPercent > 0 && G1DefaultMinNewGenPercent < 100, "Min out of bounds"); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
421 assert(G1DefaultMaxNewGenPercent > 0 && G1DefaultMaxNewGenPercent < 100, "Max out of bounds"); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
422 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
423 if (FLAG_IS_CMDLINE(NewRatio)) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
424 if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
425 warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio"); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
426 } else { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
427 _sizer_kind = SizerNewRatio; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
428 _adaptive_size = false; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
429 return; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
430 } |
3976 | 431 } |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
432 |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
433 if (FLAG_IS_CMDLINE(NewSize)) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
434 _min_desired_young_length = MAX2((size_t) 1, NewSize / HeapRegion::GrainBytes); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
435 if (FLAG_IS_CMDLINE(MaxNewSize)) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
436 _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
437 _sizer_kind = SizerMaxAndNewSize; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
438 _adaptive_size = _min_desired_young_length == _max_desired_young_length; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
439 } else { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
440 _sizer_kind = SizerNewSizeOnly; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
441 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
442 } else if (FLAG_IS_CMDLINE(MaxNewSize)) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
443 _max_desired_young_length = MAX2((size_t) 1, MaxNewSize / HeapRegion::GrainBytes); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
444 _sizer_kind = SizerMaxNewSizeOnly; |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
445 } |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
446 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
447 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
448 size_t G1YoungGenSizer::calculate_default_min_length(size_t new_number_of_heap_regions) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
449 size_t default_value = (new_number_of_heap_regions * G1DefaultMinNewGenPercent) / 100; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
450 return MAX2((size_t)1, default_value); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
451 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
452 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
453 size_t G1YoungGenSizer::calculate_default_max_length(size_t new_number_of_heap_regions) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
454 size_t default_value = (new_number_of_heap_regions * G1DefaultMaxNewGenPercent) / 100; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
455 return MAX2((size_t)1, default_value); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
456 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
457 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
458 void G1YoungGenSizer::heap_size_changed(size_t new_number_of_heap_regions) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
459 assert(new_number_of_heap_regions > 0, "Heap must be initialized"); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
460 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
461 switch (_sizer_kind) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
462 case SizerDefaults: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
463 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
464 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
465 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
466 case SizerNewSizeOnly: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
467 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
468 _max_desired_young_length = MAX2(_min_desired_young_length, _max_desired_young_length); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
469 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
470 case SizerMaxNewSizeOnly: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
471 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
472 _min_desired_young_length = MIN2(_min_desired_young_length, _max_desired_young_length); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
473 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
474 case SizerMaxAndNewSize: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
475 // Do nothing. Values set on the command line, don't update them at runtime. |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
476 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
477 case SizerNewRatio: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
478 _min_desired_young_length = new_number_of_heap_regions / (NewRatio + 1); |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
479 _max_desired_young_length = _min_desired_young_length; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
480 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
481 default: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
482 ShouldNotReachHere(); |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
483 } |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
484 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
485 assert(_min_desired_young_length <= _max_desired_young_length, "Invalid min/max young gen size values"); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
486 } |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
487 |
342 | 488 void G1CollectorPolicy::init() { |
489 // Set aside an initial future to_space. | |
490 _g1 = G1CollectedHeap::heap(); | |
491 | |
492 assert(Heap_lock->owned_by_self(), "Locking discipline."); | |
493 | |
545 | 494 initialize_gc_policy_counters(); |
495 | |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
496 if (adaptive_young_list_length()) { |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
497 _young_list_fixed_length = 0; |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
498 } else { |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
499 _young_list_fixed_length = _young_gen_sizer->min_desired_young_length(); |
342 | 500 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
501 _free_regions_at_end_of_collection = _g1->free_regions(); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
502 update_young_list_target_length(); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
503 _prev_eden_capacity = _young_list_target_length * HeapRegion::GrainBytes; |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
504 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
505 // 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
|
506 // 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
|
507 start_incremental_cset_building(); |
342 | 508 } |
509 | |
545 | 510 // Create the jstat counters for the policy. |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
511 void G1CollectorPolicy::initialize_gc_policy_counters() { |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
512 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3); |
545 | 513 } |
514 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
515 bool G1CollectorPolicy::predict_will_fit(size_t young_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
516 double base_time_ms, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
517 size_t base_free_regions, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
518 double target_pause_time_ms) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
519 if (young_length >= base_free_regions) { |
342 | 520 // end condition 1: not enough space for the young regions |
521 return false; | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
522 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
523 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
524 double accum_surv_rate = accum_yg_surv_rate_pred((int)(young_length - 1)); |
342 | 525 size_t bytes_to_copy = |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
526 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); |
342 | 527 double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
528 double young_other_time_ms = predict_young_other_time_ms(young_length); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
529 double pause_time_ms = base_time_ms + copy_time_ms + young_other_time_ms; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
530 if (pause_time_ms > target_pause_time_ms) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
531 // end condition 2: prediction is over the target pause time |
342 | 532 return false; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
533 } |
342 | 534 |
535 size_t free_bytes = | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
536 (base_free_regions - young_length) * HeapRegion::GrainBytes; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
537 if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
538 // end condition 3: out-of-space (conservatively!) |
342 | 539 return false; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
540 } |
342 | 541 |
542 // success! | |
543 return true; | |
544 } | |
545 | |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
546 void G1CollectorPolicy::record_new_heap_size(size_t new_number_of_regions) { |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
547 // re-calculate the necessary reserve |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
548 double reserve_regions_d = (double) new_number_of_regions * _reserve_factor; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
549 // We use ceiling so that if reserve_regions_d is > 0.0 (but |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
550 // smaller than 1.0) we'll get 1. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
551 _reserve_regions = (size_t) ceil(reserve_regions_d); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
552 |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
553 _young_gen_sizer->heap_size_changed(new_number_of_regions); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
554 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
555 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
556 size_t G1CollectorPolicy::calculate_young_list_desired_min_length( |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
557 size_t base_min_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
558 size_t desired_min_length = 0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
559 if (adaptive_young_list_length()) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
560 if (_alloc_rate_ms_seq->num() > 3) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
561 double now_sec = os::elapsedTime(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
562 double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
563 double alloc_rate_ms = predict_alloc_rate_ms(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
564 desired_min_length = (size_t) ceil(alloc_rate_ms * when_ms); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
565 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
566 // otherwise we don't have enough info to make the prediction |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
567 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
568 } |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
569 desired_min_length += base_min_length; |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
570 // make sure we don't go below any user-defined minimum bound |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
571 return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
572 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
573 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
574 size_t G1CollectorPolicy::calculate_young_list_desired_max_length() { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
575 // Here, we might want to also take into account any additional |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
576 // constraints (i.e., user-defined minimum bound). Currently, we |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
577 // effectively don't set this bound. |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
578 return _young_gen_sizer->max_desired_young_length(); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
579 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
580 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
581 void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
582 if (rs_lengths == (size_t) -1) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
583 // if it's set to the default value (-1), we should predict it; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
584 // otherwise, use the given value. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
585 rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
586 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
587 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
588 // Calculate the absolute and desired min bounds. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
589 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
590 // This is how many young regions we already have (currently: the survivors). |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
591 size_t base_min_length = recorded_survivor_regions(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
592 // This is the absolute minimum young length, which ensures that we |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
593 // can allocate one eden region in the worst-case. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
594 size_t absolute_min_length = base_min_length + 1; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
595 size_t desired_min_length = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
596 calculate_young_list_desired_min_length(base_min_length); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
597 if (desired_min_length < absolute_min_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
598 desired_min_length = absolute_min_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
599 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
600 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
601 // Calculate the absolute and desired max bounds. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
602 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
603 // We will try our best not to "eat" into the reserve. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
604 size_t absolute_max_length = 0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
605 if (_free_regions_at_end_of_collection > _reserve_regions) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
606 absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
607 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
608 size_t desired_max_length = calculate_young_list_desired_max_length(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
609 if (desired_max_length > absolute_max_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
610 desired_max_length = absolute_max_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
611 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
612 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
613 size_t young_list_target_length = 0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
614 if (adaptive_young_list_length()) { |
4710 | 615 if (gcs_are_young()) { |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
616 young_list_target_length = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
617 calculate_young_list_target_length(rs_lengths, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
618 base_min_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
619 desired_min_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
620 desired_max_length); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
621 _rs_lengths_prediction = rs_lengths; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
622 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
623 // Don't calculate anything and let the code below bound it to |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
624 // the desired_min_length, i.e., do the next GC as soon as |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
625 // possible to maximize how many old regions we can add to it. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
626 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
627 } else { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
628 // The user asked for a fixed young gen so we'll fix the young gen |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
629 // whether the next GC is young or mixed. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
630 young_list_target_length = _young_list_fixed_length; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
631 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
632 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
633 // Make sure we don't go over the desired max length, nor under the |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
634 // desired min length. In case they clash, desired_min_length wins |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
635 // which is why that test is second. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
636 if (young_list_target_length > desired_max_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
637 young_list_target_length = desired_max_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
638 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
639 if (young_list_target_length < desired_min_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
640 young_list_target_length = desired_min_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
641 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
642 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
643 assert(young_list_target_length > recorded_survivor_regions(), |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
644 "we should be able to allocate at least one eden region"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
645 assert(young_list_target_length >= absolute_min_length, "post-condition"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
646 _young_list_target_length = young_list_target_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
647 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
648 update_max_gc_locker_expansion(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
649 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
650 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
651 size_t |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
652 G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
653 size_t base_min_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
654 size_t desired_min_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
655 size_t desired_max_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
656 assert(adaptive_young_list_length(), "pre-condition"); |
4710 | 657 assert(gcs_are_young(), "only call this for young GCs"); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
658 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
659 // In case some edge-condition makes the desired max length too small... |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
660 if (desired_max_length <= desired_min_length) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
661 return desired_min_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
662 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
663 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
664 // We'll adjust min_young_length and max_young_length not to include |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
665 // the already allocated young regions (i.e., so they reflect the |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
666 // min and max eden regions we'll allocate). The base_min_length |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
667 // will be reflected in the predictions by the |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
668 // survivor_regions_evac_time prediction. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
669 assert(desired_min_length > base_min_length, "invariant"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
670 size_t min_young_length = desired_min_length - base_min_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
671 assert(desired_max_length > base_min_length, "invariant"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
672 size_t max_young_length = desired_max_length - base_min_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
673 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
674 double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
675 double survivor_regions_evac_time = predict_survivor_regions_evac_time(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
676 size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
677 size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
678 size_t scanned_cards = predict_young_card_num(adj_rs_lengths); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
679 double base_time_ms = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
680 predict_base_elapsed_time_ms(pending_cards, scanned_cards) + |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
681 survivor_regions_evac_time; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
682 size_t available_free_regions = _free_regions_at_end_of_collection; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
683 size_t base_free_regions = 0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
684 if (available_free_regions > _reserve_regions) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
685 base_free_regions = available_free_regions - _reserve_regions; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
686 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
687 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
688 // Here, we will make sure that the shortest young length that |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
689 // makes sense fits within the target pause time. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
690 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
691 if (predict_will_fit(min_young_length, base_time_ms, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
692 base_free_regions, target_pause_time_ms)) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
693 // The shortest young length will fit into the target pause time; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
694 // we'll now check whether the absolute maximum number of young |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
695 // regions will fit in the target pause time. If not, we'll do |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
696 // a binary search between min_young_length and max_young_length. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
697 if (predict_will_fit(max_young_length, base_time_ms, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
698 base_free_regions, target_pause_time_ms)) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
699 // The maximum young length will fit into the target pause time. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
700 // We are done so set min young length to the maximum length (as |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
701 // the result is assumed to be returned in min_young_length). |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
702 min_young_length = max_young_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
703 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
704 // The maximum possible number of young regions will not fit within |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
705 // the target pause time so we'll search for the optimal |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
706 // length. The loop invariants are: |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
707 // |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
708 // min_young_length < max_young_length |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
709 // min_young_length is known to fit into the target pause time |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
710 // max_young_length is known not to fit into the target pause time |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
711 // |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
712 // Going into the loop we know the above hold as we've just |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
713 // checked them. Every time around the loop we check whether |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
714 // the middle value between min_young_length and |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
715 // max_young_length fits into the target pause time. If it |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
716 // does, it becomes the new min. If it doesn't, it becomes |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
717 // the new max. This way we maintain the loop invariants. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
718 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
719 assert(min_young_length < max_young_length, "invariant"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
720 size_t diff = (max_young_length - min_young_length) / 2; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
721 while (diff > 0) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
722 size_t young_length = min_young_length + diff; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
723 if (predict_will_fit(young_length, base_time_ms, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
724 base_free_regions, target_pause_time_ms)) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
725 min_young_length = young_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
726 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
727 max_young_length = young_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
728 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
729 assert(min_young_length < max_young_length, "invariant"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
730 diff = (max_young_length - min_young_length) / 2; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
731 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
732 // The results is min_young_length which, according to the |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
733 // loop invariants, should fit within the target pause time. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
734 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
735 // These are the post-conditions of the binary search above: |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
736 assert(min_young_length < max_young_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
737 "otherwise we should have discovered that max_young_length " |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
738 "fits into the pause target and not done the binary search"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
739 assert(predict_will_fit(min_young_length, base_time_ms, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
740 base_free_regions, target_pause_time_ms), |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
741 "min_young_length, the result of the binary search, should " |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
742 "fit into the pause target"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
743 assert(!predict_will_fit(min_young_length + 1, base_time_ms, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
744 base_free_regions, target_pause_time_ms), |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
745 "min_young_length, the result of the binary search, should be " |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
746 "optimal, so no larger length should fit into the pause target"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
747 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
748 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
749 // Even the minimum length doesn't fit into the pause time |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
750 // target, return it as the result nevertheless. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
751 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
752 return base_min_length + min_young_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
753 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
754 |
545 | 755 double G1CollectorPolicy::predict_survivor_regions_evac_time() { |
756 double survivor_regions_evac_time = 0.0; | |
757 for (HeapRegion * r = _recorded_survivor_head; | |
758 r != NULL && r != _recorded_survivor_tail->get_next_young_region(); | |
759 r = r->get_next_young_region()) { | |
760 survivor_regions_evac_time += predict_region_elapsed_time_ms(r, true); | |
761 } | |
762 return survivor_regions_evac_time; | |
763 } | |
764 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
765 void G1CollectorPolicy::revise_young_list_target_length_if_necessary() { |
342 | 766 guarantee( adaptive_young_list_length(), "should not call this otherwise" ); |
767 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
768 size_t rs_lengths = _g1->young_list()->sampled_rs_lengths(); |
342 | 769 if (rs_lengths > _rs_lengths_prediction) { |
770 // add 10% to avoid having to recalculate often | |
771 size_t rs_lengths_prediction = rs_lengths * 1100 / 1000; | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
772 update_young_list_target_length(rs_lengths_prediction); |
342 | 773 } |
774 } | |
775 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
776 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
777 |
342 | 778 HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size, |
779 bool is_tlab, | |
780 bool* gc_overhead_limit_was_exceeded) { | |
781 guarantee(false, "Not using this policy feature yet."); | |
782 return NULL; | |
783 } | |
784 | |
785 // This method controls how a collector handles one or more | |
786 // of its generations being fully allocated. | |
787 HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size, | |
788 bool is_tlab) { | |
789 guarantee(false, "Not using this policy feature yet."); | |
790 return NULL; | |
791 } | |
792 | |
793 | |
794 #ifndef PRODUCT | |
795 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
|
796 HeapRegion* head = _g1->young_list()->first_region(); |
342 | 797 return |
798 verify_young_ages(head, _short_lived_surv_rate_group); | |
799 // also call verify_young_ages on any additional surv rate groups | |
800 } | |
801 | |
802 bool | |
803 G1CollectorPolicy::verify_young_ages(HeapRegion* head, | |
804 SurvRateGroup *surv_rate_group) { | |
805 guarantee( surv_rate_group != NULL, "pre-condition" ); | |
806 | |
807 const char* name = surv_rate_group->name(); | |
808 bool ret = true; | |
809 int prev_age = -1; | |
810 | |
811 for (HeapRegion* curr = head; | |
812 curr != NULL; | |
813 curr = curr->get_next_young_region()) { | |
814 SurvRateGroup* group = curr->surv_rate_group(); | |
815 if (group == NULL && !curr->is_survivor()) { | |
816 gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); | |
817 ret = false; | |
818 } | |
819 | |
820 if (surv_rate_group == group) { | |
821 int age = curr->age_in_surv_rate_group(); | |
822 | |
823 if (age < 0) { | |
824 gclog_or_tty->print_cr("## %s: encountered negative age", name); | |
825 ret = false; | |
826 } | |
827 | |
828 if (age <= prev_age) { | |
829 gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " | |
830 "(%d, %d)", name, age, prev_age); | |
831 ret = false; | |
832 } | |
833 prev_age = age; | |
834 } | |
835 } | |
836 | |
837 return ret; | |
838 } | |
839 #endif // PRODUCT | |
840 | |
841 void G1CollectorPolicy::record_full_collection_start() { | |
842 _cur_collection_start_sec = os::elapsedTime(); | |
843 // Release the future to-space so that it is available for compaction into. | |
844 _g1->set_full_collection(); | |
845 } | |
846 | |
847 void G1CollectorPolicy::record_full_collection_end() { | |
848 // Consider this like a collection pause for the purposes of allocation | |
849 // since last pause. | |
850 double end_sec = os::elapsedTime(); | |
851 double full_gc_time_sec = end_sec - _cur_collection_start_sec; | |
852 double full_gc_time_ms = full_gc_time_sec * 1000.0; | |
853 | |
854 _all_full_gc_times_ms->add(full_gc_time_ms); | |
855 | |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
856 update_recent_gc_times(end_sec, full_gc_time_ms); |
342 | 857 |
858 _g1->clear_full_collection(); | |
859 | |
4710 | 860 // "Nuke" the heuristics that control the young/mixed GC |
861 // transitions and make sure we start with young GCs after the Full GC. | |
862 set_gcs_are_young(true); | |
863 _last_young_gc = false; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
864 clear_initiate_conc_mark_if_possible(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
865 clear_during_initial_mark_pause(); |
342 | 866 _known_garbage_bytes = 0; |
867 _known_garbage_ratio = 0.0; | |
868 _in_marking_window = false; | |
869 _in_marking_window_im = false; | |
870 | |
871 _short_lived_surv_rate_group->start_adding_regions(); | |
872 // also call this on any additional surv rate groups | |
873 | |
545 | 874 record_survivor_regions(0, NULL, NULL); |
875 | |
342 | 876 _free_regions_at_end_of_collection = _g1->free_regions(); |
545 | 877 // Reset survivors SurvRateGroup. |
878 _survivor_surv_rate_group->reset(); | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
879 update_young_list_target_length(); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
880 _collectionSetChooser->clearMarkedHeapRegions(); |
1973 | 881 } |
342 | 882 |
883 void G1CollectorPolicy::record_stop_world_start() { | |
884 _stop_world_start = os::elapsedTime(); | |
885 } | |
886 | |
887 void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, | |
888 size_t start_used) { | |
889 if (PrintGCDetails) { | |
890 gclog_or_tty->stamp(PrintGCTimeStamps); | |
891 gclog_or_tty->print("[GC pause"); | |
4710 | 892 gclog_or_tty->print(" (%s)", gcs_are_young() ? "young" : "mixed"); |
342 | 893 } |
894 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
895 // We only need to do this here as the policy will only be applied |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
896 // to the GC we're about to start. so, no point is calculating this |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
897 // every time we calculate / recalculate the target young length. |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
898 update_survivors_policy(); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
899 |
1973 | 900 assert(_g1->used() == _g1->recalculate_used(), |
901 err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, | |
902 _g1->used(), _g1->recalculate_used())); | |
342 | 903 |
904 double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; | |
905 _all_stop_world_times_ms->add(s_w_t_ms); | |
906 _stop_world_start = 0.0; | |
907 | |
908 _cur_collection_start_sec = start_time_sec; | |
909 _cur_collection_pause_used_at_start_bytes = start_used; | |
910 _cur_collection_pause_used_regions_at_start = _g1->used_regions(); | |
911 _pending_cards = _g1->pending_card_num(); | |
912 _max_pending_cards = _g1->max_pending_card_num(); | |
913 | |
914 _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
|
915 _bytes_copied_during_gc = 0; |
342 | 916 |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
917 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
|
918 _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
|
919 _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
|
920 _capacity_before_gc = _g1->capacity(); |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
921 |
342 | 922 #ifdef DEBUG |
923 // initialise these to something well known so that we can spot | |
924 // if they are not set properly | |
925 | |
926 for (int i = 0; i < _parallel_gc_threads; ++i) { | |
1611 | 927 _par_last_gc_worker_start_times_ms[i] = -1234.0; |
928 _par_last_ext_root_scan_times_ms[i] = -1234.0; | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
929 _par_last_satb_filtering_times_ms[i] = -1234.0; |
1611 | 930 _par_last_update_rs_times_ms[i] = -1234.0; |
931 _par_last_update_rs_processed_buffers[i] = -1234.0; | |
932 _par_last_scan_rs_times_ms[i] = -1234.0; | |
933 _par_last_obj_copy_times_ms[i] = -1234.0; | |
934 _par_last_termination_times_ms[i] = -1234.0; | |
935 _par_last_termination_attempts[i] = -1234.0; | |
936 _par_last_gc_worker_end_times_ms[i] = -1234.0; | |
2430 | 937 _par_last_gc_worker_times_ms[i] = -1234.0; |
4023 | 938 _par_last_gc_worker_other_times_ms[i] = -1234.0; |
342 | 939 } |
940 #endif | |
941 | |
942 for (int i = 0; i < _aux_num; ++i) { | |
943 _cur_aux_times_ms[i] = 0.0; | |
944 _cur_aux_times_set[i] = false; | |
945 } | |
946 | |
4096
00dd86e542eb
7114303: G1: assert(_g1->mark_in_progress()) failed: shouldn't be here otherwise
johnc
parents:
4095
diff
changeset
|
947 // This is initialized to zero here and is set during |
4023 | 948 // the evacuation pause if marking is in progress. |
949 _cur_satb_drain_time_ms = 0.0; | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
950 // This is initialized to zero here and is set during the evacuation |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
951 // pause if we actually waited for the root region scanning to finish. |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
952 _root_region_scan_wait_time_ms = 0.0; |
342 | 953 |
4710 | 954 _last_gc_was_young = false; |
342 | 955 |
956 // do that for any other surv rate groups | |
957 _short_lived_surv_rate_group->stop_adding_regions(); | |
1282 | 958 _survivors_age_table.clear(); |
545 | 959 |
342 | 960 assert( verify_young_ages(), "region age verification" ); |
961 } | |
962 | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
963 void G1CollectorPolicy::record_concurrent_mark_init_end(double |
342 | 964 mark_init_elapsed_time_ms) { |
965 _during_marking = true; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
966 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
|
967 clear_during_initial_mark_pause(); |
342 | 968 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; |
969 } | |
970 | |
971 void G1CollectorPolicy::record_concurrent_mark_remark_start() { | |
972 _mark_remark_start_sec = os::elapsedTime(); | |
973 _during_marking = false; | |
974 } | |
975 | |
976 void G1CollectorPolicy::record_concurrent_mark_remark_end() { | |
977 double end_time_sec = os::elapsedTime(); | |
978 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; | |
979 _concurrent_mark_remark_times_ms->add(elapsed_time_ms); | |
980 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
981 _prev_collection_pause_end_ms += elapsed_time_ms; | |
982 | |
983 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true); | |
984 } | |
985 | |
986 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { | |
987 _mark_cleanup_start_sec = os::elapsedTime(); | |
988 } | |
989 | |
4013 | 990 void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { |
4710 | 991 _last_young_gc = true; |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
992 _in_marking_window = false; |
342 | 993 } |
994 | |
995 void G1CollectorPolicy::record_concurrent_pause() { | |
996 if (_stop_world_start > 0.0) { | |
997 double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0; | |
998 _all_yield_times_ms->add(yield_ms); | |
999 } | |
1000 } | |
1001 | |
1002 void G1CollectorPolicy::record_concurrent_pause_end() { | |
1003 } | |
1004 | |
1005 template<class T> | |
1006 T sum_of(T* sum_arr, int start, int n, int N) { | |
1007 T sum = (T)0; | |
1008 for (int i = 0; i < n; i++) { | |
1009 int j = (start + i) % N; | |
1010 sum += sum_arr[j]; | |
1011 } | |
1012 return sum; | |
1013 } | |
1014 | |
1611 | 1015 void G1CollectorPolicy::print_par_stats(int level, |
1016 const char* str, | |
2430 | 1017 double* data) { |
342 | 1018 double min = data[0], max = data[0]; |
1019 double total = 0.0; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1020 LineBuffer buf(level); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1021 buf.append("[%s (ms):", str); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1022 for (uint i = 0; i < no_of_gc_threads(); ++i) { |
342 | 1023 double val = data[i]; |
1024 if (val < min) | |
1025 min = val; | |
1026 if (val > max) | |
1027 max = val; | |
1028 total += val; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1029 buf.append(" %3.1lf", val); |
342 | 1030 } |
2430 | 1031 buf.append_and_print_cr(""); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1032 double avg = total / (double) no_of_gc_threads(); |
2430 | 1033 buf.append_and_print_cr(" Avg: %5.1lf, Min: %5.1lf, Max: %5.1lf, Diff: %5.1lf]", |
1034 avg, min, max, max - min); | |
342 | 1035 } |
1036 | |
1611 | 1037 void G1CollectorPolicy::print_par_sizes(int level, |
1038 const char* str, | |
2430 | 1039 double* data) { |
342 | 1040 double min = data[0], max = data[0]; |
1041 double total = 0.0; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1042 LineBuffer buf(level); |
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1043 buf.append("[%s :", str); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1044 for (uint i = 0; i < no_of_gc_threads(); ++i) { |
342 | 1045 double val = data[i]; |
1046 if (val < min) | |
1047 min = val; | |
1048 if (val > max) | |
1049 max = val; | |
1050 total += val; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1051 buf.append(" %d", (int) val); |
342 | 1052 } |
2430 | 1053 buf.append_and_print_cr(""); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1054 double avg = total / (double) no_of_gc_threads(); |
2430 | 1055 buf.append_and_print_cr(" Sum: %d, Avg: %d, Min: %d, Max: %d, Diff: %d]", |
1056 (int)total, (int)avg, (int)min, (int)max, (int)max - (int)min); | |
342 | 1057 } |
1058 | |
4023 | 1059 void G1CollectorPolicy::print_stats(int level, |
1060 const char* str, | |
1061 double value) { | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1062 LineBuffer(level).append_and_print_cr("[%s: %5.1lf ms]", str, value); |
342 | 1063 } |
1064 | |
4023 | 1065 void G1CollectorPolicy::print_stats(int level, |
1066 const char* str, | |
1067 int value) { | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1068 LineBuffer(level).append_and_print_cr("[%s: %d]", str, value); |
342 | 1069 } |
1070 | |
4023 | 1071 double G1CollectorPolicy::avg_value(double* data) { |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1072 if (G1CollectedHeap::use_parallel_gc_threads()) { |
342 | 1073 double ret = 0.0; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1074 for (uint i = 0; i < no_of_gc_threads(); ++i) { |
342 | 1075 ret += data[i]; |
4023 | 1076 } |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1077 return ret / (double) no_of_gc_threads(); |
342 | 1078 } else { |
1079 return data[0]; | |
1080 } | |
1081 } | |
1082 | |
4023 | 1083 double G1CollectorPolicy::max_value(double* data) { |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1084 if (G1CollectedHeap::use_parallel_gc_threads()) { |
342 | 1085 double ret = data[0]; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1086 for (uint i = 1; i < no_of_gc_threads(); ++i) { |
4023 | 1087 if (data[i] > ret) { |
342 | 1088 ret = data[i]; |
4023 | 1089 } |
1090 } | |
342 | 1091 return ret; |
1092 } else { | |
1093 return data[0]; | |
1094 } | |
1095 } | |
1096 | |
4023 | 1097 double G1CollectorPolicy::sum_of_values(double* data) { |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1098 if (G1CollectedHeap::use_parallel_gc_threads()) { |
342 | 1099 double sum = 0.0; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1100 for (uint i = 0; i < no_of_gc_threads(); i++) { |
342 | 1101 sum += data[i]; |
4023 | 1102 } |
342 | 1103 return sum; |
1104 } else { | |
1105 return data[0]; | |
1106 } | |
1107 } | |
1108 | |
4023 | 1109 double G1CollectorPolicy::max_sum(double* data1, double* data2) { |
342 | 1110 double ret = data1[0] + data2[0]; |
1111 | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1112 if (G1CollectedHeap::use_parallel_gc_threads()) { |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1113 for (uint i = 1; i < no_of_gc_threads(); ++i) { |
342 | 1114 double data = data1[i] + data2[i]; |
4023 | 1115 if (data > ret) { |
342 | 1116 ret = data; |
4023 | 1117 } |
342 | 1118 } |
1119 } | |
1120 return ret; | |
1121 } | |
1122 | |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1123 bool G1CollectorPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) { |
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1124 if (_g1->concurrent_mark()->cmThread()->during_cycle()) { |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1125 return false; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1126 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1127 |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1128 size_t marking_initiating_used_threshold = |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1129 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1130 size_t cur_used_bytes = _g1->non_young_capacity_bytes(); |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1131 size_t alloc_byte_size = alloc_word_size * HeapWordSize; |
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1132 |
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1133 if ((cur_used_bytes + alloc_byte_size) > marking_initiating_used_threshold) { |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1134 if (gcs_are_young()) { |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1135 ergo_verbose5(ErgoConcCycles, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1136 "request concurrent cycle initiation", |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1137 ergo_format_reason("occupancy higher than threshold") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1138 ergo_format_byte("occupancy") |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1139 ergo_format_byte("allocation request") |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1140 ergo_format_byte_perc("threshold") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1141 ergo_format_str("source"), |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1142 cur_used_bytes, |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1143 alloc_byte_size, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1144 marking_initiating_used_threshold, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1145 (double) InitiatingHeapOccupancyPercent, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1146 source); |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1147 return true; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1148 } else { |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1149 ergo_verbose5(ErgoConcCycles, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1150 "do not request concurrent cycle initiation", |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1151 ergo_format_reason("still doing mixed collections") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1152 ergo_format_byte("occupancy") |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1153 ergo_format_byte("allocation request") |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1154 ergo_format_byte_perc("threshold") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1155 ergo_format_str("source"), |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1156 cur_used_bytes, |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
1157 alloc_byte_size, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1158 marking_initiating_used_threshold, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1159 (double) InitiatingHeapOccupancyPercent, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1160 source); |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1161 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1162 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1163 |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1164 return false; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1165 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1166 |
342 | 1167 // Anything below that is considered to be zero |
1168 #define MIN_TIMER_GRANULARITY 0.0000001 | |
1169 | |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1170 void G1CollectorPolicy::record_collection_pause_end(int no_of_gc_threads) { |
342 | 1171 double end_time_sec = os::elapsedTime(); |
1172 double elapsed_ms = _last_pause_time_ms; | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1173 bool parallel = G1CollectedHeap::use_parallel_gc_threads(); |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1174 assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1175 "otherwise, the subtraction below does not make sense"); |
342 | 1176 size_t rs_size = |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1177 _cur_collection_pause_used_regions_at_start - cset_region_length(); |
342 | 1178 size_t cur_used_bytes = _g1->used(); |
1179 assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); | |
1180 bool last_pause_included_initial_mark = false; | |
1707 | 1181 bool update_stats = !_g1->evacuation_failed(); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1182 set_no_of_gc_threads(no_of_gc_threads); |
342 | 1183 |
1184 #ifndef PRODUCT | |
1185 if (G1YoungSurvRateVerbose) { | |
1186 gclog_or_tty->print_cr(""); | |
1187 _short_lived_surv_rate_group->print(); | |
1188 // do that for any other surv rate groups too | |
1189 } | |
1190 #endif // PRODUCT | |
1191 | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1192 last_pause_included_initial_mark = during_initial_mark_pause(); |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1193 if (last_pause_included_initial_mark) { |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1194 record_concurrent_mark_init_end(0.0); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1195 } else if (!_last_young_gc && need_to_start_conc_mark("end of GC")) { |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1196 // Note: this might have already been set, if during the last |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1197 // pause we decided to start a cycle but at the beginning of |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1198 // this pause we decided to postpone it. That's OK. |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1199 set_initiate_conc_mark_if_possible(); |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1200 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1201 |
342 | 1202 _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0, |
1203 end_time_sec, false); | |
1204 | |
1205 // This assert is exempted when we're doing parallel collection pauses, | |
1206 // because the fragmentation caused by the parallel GC allocation buffers | |
1207 // can lead to more memory being used during collection than was used | |
1208 // before. Best leave this out until the fragmentation problem is fixed. | |
1209 // Pauses in which evacuation failed can also lead to negative | |
1210 // collections, since no space is reclaimed from a region containing an | |
1211 // object whose evacuation failed. | |
1212 // Further, we're now always doing parallel collection. But I'm still | |
1213 // leaving this here as a placeholder for a more precise assertion later. | |
1214 // (DLD, 10/05.) | |
1215 assert((true || parallel) // Always using GC LABs now. | |
1216 || _g1->evacuation_failed() | |
1217 || _cur_collection_pause_used_at_start_bytes >= cur_used_bytes, | |
1218 "Negative collection"); | |
1219 | |
1220 size_t freed_bytes = | |
1221 _cur_collection_pause_used_at_start_bytes - cur_used_bytes; | |
1222 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
|
1223 |
342 | 1224 double survival_fraction = |
1225 (double)surviving_bytes/ | |
1226 (double)_collection_set_bytes_used_before; | |
1227 | |
4023 | 1228 // These values are used to update the summary information that is |
1229 // displayed when TraceGen0Time is enabled, and are output as part | |
1230 // of the PrintGCDetails output, in the non-parallel case. | |
1231 | |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1232 double ext_root_scan_time = avg_value(_par_last_ext_root_scan_times_ms); |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1233 double satb_filtering_time = avg_value(_par_last_satb_filtering_times_ms); |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1234 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
|
1235 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
|
1236 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
|
1237 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
|
1238 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
|
1239 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
|
1240 |
4023 | 1241 double known_time = ext_root_scan_time + |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1242 satb_filtering_time + |
4023 | 1243 update_rs_time + |
1244 scan_rs_time + | |
1245 obj_copy_time; | |
1246 | |
1247 double other_time_ms = elapsed_ms; | |
1248 | |
1249 // Subtract the SATB drain time. It's initialized to zero at the | |
1250 // start of the pause and is updated during the pause if marking | |
1251 // is in progress. | |
1252 other_time_ms -= _cur_satb_drain_time_ms; | |
1253 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1254 // Subtract the root region scanning wait time. It's initialized to |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1255 // zero at the start of the pause. |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1256 other_time_ms -= _root_region_scan_wait_time_ms; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1257 |
4023 | 1258 if (parallel) { |
1259 other_time_ms -= _cur_collection_par_time_ms; | |
1260 } else { | |
1261 other_time_ms -= known_time; | |
1262 } | |
1263 | |
1264 // Subtract the time taken to clean the card table from the | |
1265 // current value of "other time" | |
1266 other_time_ms -= _cur_clear_ct_time_ms; | |
1267 | |
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1268 // Subtract the time spent completing marking in the collection |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1269 // set. Note if marking is not in progress during the pause |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1270 // the value of _mark_closure_time_ms will be zero. |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1271 other_time_ms -= _mark_closure_time_ms; |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1272 |
4023 | 1273 // TraceGen0Time and TraceGen1Time summary info updating. |
1274 _all_pause_times_ms->add(elapsed_ms); | |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1275 |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
1276 if (update_stats) { |
4023 | 1277 _summary->record_total_time_ms(elapsed_ms); |
1278 _summary->record_other_time_ms(other_time_ms); | |
1279 | |
1280 MainBodySummary* body_summary = _summary->main_body_summary(); | |
1281 assert(body_summary != NULL, "should not be null!"); | |
1282 | |
1283 // This will be non-zero iff marking is currently in progress (i.e. | |
1284 // _g1->mark_in_progress() == true) and the currrent pause was not | |
1285 // an initial mark pause. Since the body_summary items are NumberSeqs, | |
1286 // however, they have to be consistent and updated in lock-step with | |
1287 // each other. Therefore we unconditionally record the SATB drain | |
1288 // time - even if it's zero. | |
1289 body_summary->record_satb_drain_time_ms(_cur_satb_drain_time_ms); | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1290 body_summary->record_root_region_scan_wait_time_ms( |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1291 _root_region_scan_wait_time_ms); |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1292 |
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1293 body_summary->record_ext_root_scan_time_ms(ext_root_scan_time); |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1294 body_summary->record_satb_filtering_time_ms(satb_filtering_time); |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1295 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
|
1296 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
|
1297 body_summary->record_obj_copy_time_ms(obj_copy_time); |
4023 | 1298 |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1299 if (parallel) { |
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1300 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
|
1301 body_summary->record_termination_time_ms(termination_time); |
4023 | 1302 |
1303 double parallel_known_time = known_time + termination_time; | |
1304 double parallel_other_time = _cur_collection_par_time_ms - parallel_known_time; | |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1305 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
|
1306 } |
4023 | 1307 |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1308 body_summary->record_mark_closure_time_ms(_mark_closure_time_ms); |
4023 | 1309 body_summary->record_clear_ct_time_ms(_cur_clear_ct_time_ms); |
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
1310 |
342 | 1311 // We exempt parallel collection from this check because Alloc Buffer |
1312 // fragmentation can produce negative collections. Same with evac | |
1313 // failure. | |
1314 // Further, we're now always doing parallel collection. But I'm still | |
1315 // leaving this here as a placeholder for a more precise assertion later. | |
1316 // (DLD, 10/05. | |
1317 assert((true || parallel) | |
1318 || _g1->evacuation_failed() | |
1319 || surviving_bytes <= _collection_set_bytes_used_before, | |
1320 "Or else negative collection!"); | |
4023 | 1321 |
342 | 1322 // this is where we update the allocation rate of the application |
1323 double app_time_ms = | |
1324 (_cur_collection_start_sec * 1000.0 - _prev_collection_pause_end_ms); | |
1325 if (app_time_ms < MIN_TIMER_GRANULARITY) { | |
1326 // This usually happens due to the timer not having the required | |
1327 // granularity. Some Linuxes are the usual culprits. | |
1328 // We'll just set it to something (arbitrarily) small. | |
1329 app_time_ms = 1.0; | |
1330 } | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1331 // We maintain the invariant that all objects allocated by mutator |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1332 // threads will be allocated out of eden regions. So, we can use |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1333 // the eden region number allocated since the previous GC to |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1334 // calculate the application's allocate rate. The only exception |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1335 // to that is humongous objects that are allocated separately. But |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1336 // given that humongous object allocations do not really affect |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1337 // either the pause's duration nor when the next pause will take |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1338 // place we can safely ignore them here. |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1339 size_t regions_allocated = eden_cset_region_length(); |
342 | 1340 double alloc_rate_ms = (double) regions_allocated / app_time_ms; |
1341 _alloc_rate_ms_seq->add(alloc_rate_ms); | |
1342 | |
1343 double interval_ms = | |
1344 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; | |
1345 update_recent_gc_times(end_time_sec, elapsed_ms); | |
1346 _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
|
1347 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
|
1348 (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
|
1349 #ifndef PRODUCT |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1350 // 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
|
1351 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
|
1352 gclog_or_tty->print_cr("-------------------------------------------"); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1353 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
|
1354 _recent_gc_times_ms->dump(); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1355 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
|
1356 _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
|
1357 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
|
1358 _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
|
1359 // 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
|
1360 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
|
1361 #endif // !PRODUCT |
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
1362 // 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
|
1363 // 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
|
1364 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
|
1365 _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
|
1366 } else { |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1367 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
|
1368 _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
|
1369 } |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1370 } |
342 | 1371 } |
1372 | |
4023 | 1373 for (int i = 0; i < _aux_num; ++i) { |
1374 if (_cur_aux_times_set[i]) { | |
1375 _all_aux_times_ms[i].add(_cur_aux_times_ms[i]); | |
1376 } | |
1377 } | |
1378 | |
1379 // PrintGCDetails output | |
342 | 1380 if (PrintGCDetails) { |
4023 | 1381 bool print_marking_info = |
1382 _g1->mark_in_progress() && !last_pause_included_initial_mark; | |
1383 | |
1707 | 1384 gclog_or_tty->print_cr("%s, %1.8lf secs]", |
342 | 1385 (last_pause_included_initial_mark) ? " (initial-mark)" : "", |
1386 elapsed_ms / 1000.0); | |
1387 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1388 if (_root_region_scan_wait_time_ms > 0.0) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1389 print_stats(1, "Root Region Scan Waiting", _root_region_scan_wait_time_ms); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1390 } |
1707 | 1391 if (parallel) { |
1392 print_stats(1, "Parallel Time", _cur_collection_par_time_ms); | |
4023 | 1393 print_par_stats(2, "GC Worker Start", _par_last_gc_worker_start_times_ms); |
1394 print_par_stats(2, "Ext Root Scanning", _par_last_ext_root_scan_times_ms); | |
1395 if (print_marking_info) { | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1396 print_par_stats(2, "SATB Filtering", _par_last_satb_filtering_times_ms); |
4023 | 1397 } |
1707 | 1398 print_par_stats(2, "Update RS", _par_last_update_rs_times_ms); |
2430 | 1399 print_par_sizes(3, "Processed Buffers", _par_last_update_rs_processed_buffers); |
1707 | 1400 print_par_stats(2, "Scan RS", _par_last_scan_rs_times_ms); |
1401 print_par_stats(2, "Object Copy", _par_last_obj_copy_times_ms); | |
1402 print_par_stats(2, "Termination", _par_last_termination_times_ms); | |
2430 | 1403 print_par_sizes(3, "Termination Attempts", _par_last_termination_attempts); |
4023 | 1404 print_par_stats(2, "GC Worker End", _par_last_gc_worker_end_times_ms); |
2430 | 1405 |
1406 for (int i = 0; i < _parallel_gc_threads; i++) { | |
1407 _par_last_gc_worker_times_ms[i] = _par_last_gc_worker_end_times_ms[i] - _par_last_gc_worker_start_times_ms[i]; | |
4023 | 1408 |
1409 double worker_known_time = _par_last_ext_root_scan_times_ms[i] + | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1410 _par_last_satb_filtering_times_ms[i] + |
4023 | 1411 _par_last_update_rs_times_ms[i] + |
1412 _par_last_scan_rs_times_ms[i] + | |
1413 _par_last_obj_copy_times_ms[i] + | |
1414 _par_last_termination_times_ms[i]; | |
1415 | |
1416 _par_last_gc_worker_other_times_ms[i] = _cur_collection_par_time_ms - worker_known_time; | |
2430 | 1417 } |
4023 | 1418 print_par_stats(2, "GC Worker", _par_last_gc_worker_times_ms); |
1419 print_par_stats(2, "GC Worker Other", _par_last_gc_worker_other_times_ms); | |
1707 | 1420 } else { |
4023 | 1421 print_stats(1, "Ext Root Scanning", ext_root_scan_time); |
1422 if (print_marking_info) { | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1423 print_stats(1, "SATB Filtering", satb_filtering_time); |
4023 | 1424 } |
1707 | 1425 print_stats(1, "Update RS", update_rs_time); |
4023 | 1426 print_stats(2, "Processed Buffers", (int)update_rs_processed_buffers); |
1707 | 1427 print_stats(1, "Scan RS", scan_rs_time); |
1428 print_stats(1, "Object Copying", obj_copy_time); | |
342 | 1429 } |
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1430 if (print_marking_info) { |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1431 print_stats(1, "Complete CSet Marking", _mark_closure_time_ms); |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1432 } |
4023 | 1433 print_stats(1, "Clear CT", _cur_clear_ct_time_ms); |
890
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1434 #ifndef PRODUCT |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1435 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
|
1436 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
|
1437 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
|
1438 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
|
1439 if (_num_cc_clears > 0) { |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1440 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
|
1441 } |
6cb8e9df7174
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
845
diff
changeset
|
1442 #endif |
342 | 1443 print_stats(1, "Other", other_time_ms); |
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1444 print_stats(2, "Choose CSet", |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1445 (_recorded_young_cset_choice_time_ms + |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1446 _recorded_non_young_cset_choice_time_ms)); |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
1447 print_stats(2, "Ref Proc", _cur_ref_proc_time_ms); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3976
diff
changeset
|
1448 print_stats(2, "Ref Enq", _cur_ref_enq_time_ms); |
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1449 print_stats(2, "Free CSet", |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1450 (_recorded_young_free_cset_time_ms + |
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4096
diff
changeset
|
1451 _recorded_non_young_free_cset_time_ms)); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1452 |
342 | 1453 for (int i = 0; i < _aux_num; ++i) { |
1454 if (_cur_aux_times_set[i]) { | |
1455 char buffer[96]; | |
1456 sprintf(buffer, "Aux%d", i); | |
1457 print_stats(1, buffer, _cur_aux_times_ms[i]); | |
1458 } | |
1459 } | |
1460 } | |
1461 | |
1462 // Update the efficiency-since-mark vars. | |
1463 double proc_ms = elapsed_ms * (double) _parallel_gc_threads; | |
1464 if (elapsed_ms < MIN_TIMER_GRANULARITY) { | |
1465 // This usually happens due to the timer not having the required | |
1466 // granularity. Some Linuxes are the usual culprits. | |
1467 // We'll just set it to something (arbitrarily) small. | |
1468 proc_ms = 1.0; | |
1469 } | |
1470 double cur_efficiency = (double) freed_bytes / proc_ms; | |
1471 | |
1472 bool new_in_marking_window = _in_marking_window; | |
1473 bool new_in_marking_window_im = false; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1474 if (during_initial_mark_pause()) { |
342 | 1475 new_in_marking_window = true; |
1476 new_in_marking_window_im = true; | |
1477 } | |
1478 | |
4710 | 1479 if (_last_young_gc) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1480 // This is supposed to to be the "last young GC" before we start |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1481 // doing mixed GCs. Here we decide whether to start mixed GCs or not. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1482 |
3982
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3979
diff
changeset
|
1483 if (!last_pause_included_initial_mark) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1484 if (next_gc_should_be_mixed("start mixed GCs", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1485 "do not start mixed GCs")) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1486 set_gcs_are_young(false); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1487 } |
3982
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3979
diff
changeset
|
1488 } else { |
4710 | 1489 ergo_verbose0(ErgoMixedGCs, |
1490 "do not start mixed GCs", | |
3982
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3979
diff
changeset
|
1491 ergo_format_reason("concurrent cycle is about to start")); |
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3979
diff
changeset
|
1492 } |
4710 | 1493 _last_young_gc = false; |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1494 } |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1495 |
4710 | 1496 if (!_last_gc_was_young) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1497 // This is a mixed GC. Here we decide whether to continue doing |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1498 // mixed GCs or not. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1499 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1500 if (!next_gc_should_be_mixed("continue mixed GCs", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1501 "do not continue mixed GCs")) { |
4710 | 1502 set_gcs_are_young(true); |
342 | 1503 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1504 } |
4710 | 1505 |
1506 if (_last_gc_was_young && !_during_marking) { | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1507 _young_gc_eff_seq->add(cur_efficiency); |
342 | 1508 } |
1509 | |
1510 _short_lived_surv_rate_group->start_adding_regions(); | |
1511 // do that for any other surv rate groupsx | |
1512 | |
677 | 1513 if (update_stats) { |
342 | 1514 double pause_time_ms = elapsed_ms; |
1515 | |
1516 size_t diff = 0; | |
1517 if (_max_pending_cards >= _pending_cards) | |
1518 diff = _max_pending_cards - _pending_cards; | |
1519 _pending_card_diff_seq->add((double) diff); | |
1520 | |
1521 double cost_per_card_ms = 0.0; | |
1522 if (_pending_cards > 0) { | |
1523 cost_per_card_ms = update_rs_time / (double) _pending_cards; | |
1524 _cost_per_card_ms_seq->add(cost_per_card_ms); | |
1525 } | |
1526 | |
1527 size_t cards_scanned = _g1->cards_scanned(); | |
1528 | |
1529 double cost_per_entry_ms = 0.0; | |
1530 if (cards_scanned > 10) { | |
1531 cost_per_entry_ms = scan_rs_time / (double) cards_scanned; | |
4710 | 1532 if (_last_gc_was_young) { |
342 | 1533 _cost_per_entry_ms_seq->add(cost_per_entry_ms); |
4710 | 1534 } else { |
1535 _mixed_cost_per_entry_ms_seq->add(cost_per_entry_ms); | |
1536 } | |
342 | 1537 } |
1538 | |
1539 if (_max_rs_lengths > 0) { | |
1540 double cards_per_entry_ratio = | |
1541 (double) cards_scanned / (double) _max_rs_lengths; | |
4710 | 1542 if (_last_gc_was_young) { |
1543 _young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
1544 } else { | |
1545 _mixed_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
1546 } | |
342 | 1547 } |
1548 | |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1549 // This is defensive. For a while _max_rs_lengths could get |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1550 // smaller than _recorded_rs_lengths which was causing |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1551 // rs_length_diff to get very large and mess up the RSet length |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1552 // predictions. The reason was unsafe concurrent updates to the |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1553 // _inc_cset_recorded_rs_lengths field which the code below guards |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1554 // against (see CR 7118202). This bug has now been fixed (see CR |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1555 // 7119027). However, I'm still worried that |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1556 // _inc_cset_recorded_rs_lengths might still end up somewhat |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1557 // inaccurate. The concurrent refinement thread calculates an |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1558 // RSet's length concurrently with other CR threads updating it |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1559 // which might cause it to calculate the length incorrectly (if, |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1560 // say, it's in mid-coarsening). So I'll leave in the defensive |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1561 // conditional below just in case. |
4130
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1562 size_t rs_length_diff = 0; |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1563 if (_max_rs_lengths > _recorded_rs_lengths) { |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1564 rs_length_diff = _max_rs_lengths - _recorded_rs_lengths; |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1565 } |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1566 _rs_length_diff_seq->add((double) rs_length_diff); |
342 | 1567 |
1568 size_t copied_bytes = surviving_bytes; | |
1569 double cost_per_byte_ms = 0.0; | |
1570 if (copied_bytes > 0) { | |
1571 cost_per_byte_ms = obj_copy_time / (double) copied_bytes; | |
4710 | 1572 if (_in_marking_window) { |
342 | 1573 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); |
4710 | 1574 } else { |
342 | 1575 _cost_per_byte_ms_seq->add(cost_per_byte_ms); |
4710 | 1576 } |
342 | 1577 } |
1578 | |
1579 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
|
1580 (update_rs_time + scan_rs_time + obj_copy_time + |
342 | 1581 _mark_closure_time_ms + termination_time); |
1582 | |
1583 double young_other_time_ms = 0.0; | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1584 if (young_cset_region_length() > 0) { |
342 | 1585 young_other_time_ms = |
1586 _recorded_young_cset_choice_time_ms + | |
1587 _recorded_young_free_cset_time_ms; | |
1588 _young_other_cost_per_region_ms_seq->add(young_other_time_ms / | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1589 (double) young_cset_region_length()); |
342 | 1590 } |
1591 double non_young_other_time_ms = 0.0; | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1592 if (old_cset_region_length() > 0) { |
342 | 1593 non_young_other_time_ms = |
1594 _recorded_non_young_cset_choice_time_ms + | |
1595 _recorded_non_young_free_cset_time_ms; | |
1596 | |
1597 _non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms / | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1598 (double) old_cset_region_length()); |
342 | 1599 } |
1600 | |
1601 double constant_other_time_ms = all_other_time_ms - | |
1602 (young_other_time_ms + non_young_other_time_ms); | |
1603 _constant_other_time_ms_seq->add(constant_other_time_ms); | |
1604 | |
1605 double survival_ratio = 0.0; | |
1606 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
|
1607 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
|
1608 (double) _bytes_in_collection_set_before_gc; |
342 | 1609 } |
1610 | |
1611 _pending_cards_seq->add((double) _pending_cards); | |
1612 _rs_lengths_seq->add((double) _max_rs_lengths); | |
1613 } | |
1614 | |
1615 _in_marking_window = new_in_marking_window; | |
1616 _in_marking_window_im = new_in_marking_window_im; | |
1617 _free_regions_at_end_of_collection = _g1->free_regions(); | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1618 update_young_list_target_length(); |
342 | 1619 |
1111 | 1620 // Note that _mmu_tracker->max_gc_time() returns the time in seconds. |
1282 | 1621 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; |
1111 | 1622 adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms); |
4013 | 1623 |
1624 assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end."); | |
342 | 1625 } |
1626 | |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1627 #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
|
1628 #define EXT_SIZE_PARAMS(bytes) \ |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1629 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
|
1630 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
|
1631 |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1632 void G1CollectorPolicy::print_heap_transition() { |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1633 if (PrintGCDetails) { |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1634 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
|
1635 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
|
1636 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
|
1637 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
|
1638 size_t used = _g1->used(); |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1639 size_t capacity = _g1->capacity(); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1640 size_t eden_capacity = |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1641 (_young_list_target_length * HeapRegion::GrainBytes) - survivor_bytes; |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1642 |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1643 gclog_or_tty->print_cr( |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1644 " [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") " |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1645 "Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1646 "Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1647 EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1648 EXT_SIZE_PARAMS(_eden_bytes_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1649 EXT_SIZE_PARAMS(_prev_eden_capacity), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1650 EXT_SIZE_PARAMS(eden_bytes), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1651 EXT_SIZE_PARAMS(eden_capacity), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1652 EXT_SIZE_PARAMS(_survivor_bytes_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1653 EXT_SIZE_PARAMS(survivor_bytes), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1654 EXT_SIZE_PARAMS(used_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1655 EXT_SIZE_PARAMS(_capacity_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1656 EXT_SIZE_PARAMS(used), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1657 EXT_SIZE_PARAMS(capacity)); |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1658 |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1659 _prev_eden_capacity = eden_capacity; |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1660 } else if (PrintGC) { |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1661 _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
|
1662 _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
|
1663 _g1->used(), _g1->capacity()); |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1664 } |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1665 } |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1666 |
1111 | 1667 void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time, |
1668 double update_rs_processed_buffers, | |
1669 double goal_ms) { | |
1670 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
1671 ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine(); | |
1672 | |
1282 | 1673 if (G1UseAdaptiveConcRefinement) { |
1111 | 1674 const int k_gy = 3, k_gr = 6; |
1675 const double inc_k = 1.1, dec_k = 0.9; | |
1676 | |
1677 int g = cg1r->green_zone(); | |
1678 if (update_rs_time > goal_ms) { | |
1679 g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing. | |
1680 } else { | |
1681 if (update_rs_time < goal_ms && update_rs_processed_buffers > g) { | |
1682 g = (int)MAX2(g * inc_k, g + 1.0); | |
1683 } | |
1684 } | |
1685 // Change the refinement threads params | |
1686 cg1r->set_green_zone(g); | |
1687 cg1r->set_yellow_zone(g * k_gy); | |
1688 cg1r->set_red_zone(g * k_gr); | |
1689 cg1r->reinitialize_threads(); | |
1690 | |
1691 int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1); | |
1692 int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta, | |
1693 cg1r->yellow_zone()); | |
1694 // Change the barrier params | |
1695 dcqs.set_process_completed_threshold(processing_threshold); | |
1696 dcqs.set_max_completed_queue(cg1r->red_zone()); | |
1697 } | |
1698 | |
1699 int curr_queue_size = dcqs.completed_buffers_num(); | |
1700 if (curr_queue_size >= cg1r->yellow_zone()) { | |
1701 dcqs.set_completed_queue_padding(curr_queue_size); | |
1702 } else { | |
1703 dcqs.set_completed_queue_padding(0); | |
1704 } | |
1705 dcqs.notify_if_necessary(); | |
1706 } | |
1707 | |
342 | 1708 double |
1709 G1CollectorPolicy:: | |
1710 predict_young_collection_elapsed_time_ms(size_t adjustment) { | |
1711 guarantee( adjustment == 0 || adjustment == 1, "invariant" ); | |
1712 | |
1713 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
|
1714 size_t young_num = g1h->young_list()->length(); |
342 | 1715 if (young_num == 0) |
1716 return 0.0; | |
1717 | |
1718 young_num += adjustment; | |
1719 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
|
1720 size_t rs_lengths = g1h->young_list()->sampled_rs_lengths() + |
342 | 1721 predict_rs_length_diff(); |
1722 size_t card_num; | |
4710 | 1723 if (gcs_are_young()) { |
342 | 1724 card_num = predict_young_card_num(rs_lengths); |
4710 | 1725 } else { |
342 | 1726 card_num = predict_non_young_card_num(rs_lengths); |
4710 | 1727 } |
342 | 1728 size_t young_byte_size = young_num * HeapRegion::GrainBytes; |
1729 double accum_yg_surv_rate = | |
1730 _short_lived_surv_rate_group->accum_surv_rate(adjustment); | |
1731 | |
1732 size_t bytes_to_copy = | |
1733 (size_t) (accum_yg_surv_rate * (double) HeapRegion::GrainBytes); | |
1734 | |
1735 return | |
1736 predict_rs_update_time_ms(pending_cards) + | |
1737 predict_rs_scan_time_ms(card_num) + | |
1738 predict_object_copy_time_ms(bytes_to_copy) + | |
1739 predict_young_other_time_ms(young_num) + | |
1740 predict_constant_other_time_ms(); | |
1741 } | |
1742 | |
1743 double | |
1744 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { | |
1745 size_t rs_length = predict_rs_length_diff(); | |
1746 size_t card_num; | |
4710 | 1747 if (gcs_are_young()) { |
342 | 1748 card_num = predict_young_card_num(rs_length); |
4710 | 1749 } else { |
342 | 1750 card_num = predict_non_young_card_num(rs_length); |
4710 | 1751 } |
342 | 1752 return predict_base_elapsed_time_ms(pending_cards, card_num); |
1753 } | |
1754 | |
1755 double | |
1756 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, | |
1757 size_t scanned_cards) { | |
1758 return | |
1759 predict_rs_update_time_ms(pending_cards) + | |
1760 predict_rs_scan_time_ms(scanned_cards) + | |
1761 predict_constant_other_time_ms(); | |
1762 } | |
1763 | |
1764 double | |
1765 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, | |
1766 bool young) { | |
1767 size_t rs_length = hr->rem_set()->occupied(); | |
1768 size_t card_num; | |
4710 | 1769 if (gcs_are_young()) { |
342 | 1770 card_num = predict_young_card_num(rs_length); |
4710 | 1771 } else { |
342 | 1772 card_num = predict_non_young_card_num(rs_length); |
4710 | 1773 } |
342 | 1774 size_t bytes_to_copy = predict_bytes_to_copy(hr); |
1775 | |
1776 double region_elapsed_time_ms = | |
1777 predict_rs_scan_time_ms(card_num) + | |
1778 predict_object_copy_time_ms(bytes_to_copy); | |
1779 | |
1780 if (young) | |
1781 region_elapsed_time_ms += predict_young_other_time_ms(1); | |
1782 else | |
1783 region_elapsed_time_ms += predict_non_young_other_time_ms(1); | |
1784 | |
1785 return region_elapsed_time_ms; | |
1786 } | |
1787 | |
1788 size_t | |
1789 G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { | |
1790 size_t bytes_to_copy; | |
1791 if (hr->is_marked()) | |
1792 bytes_to_copy = hr->max_live_bytes(); | |
1793 else { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1794 assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant"); |
342 | 1795 int age = hr->age_in_surv_rate_group(); |
545 | 1796 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); |
342 | 1797 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate); |
1798 } | |
1799 return bytes_to_copy; | |
1800 } | |
1801 | |
1802 void | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1803 G1CollectorPolicy::init_cset_region_lengths(size_t eden_cset_region_length, |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1804 size_t survivor_cset_region_length) { |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1805 _eden_cset_region_length = eden_cset_region_length; |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1806 _survivor_cset_region_length = survivor_cset_region_length; |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1807 _old_cset_region_length = 0; |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1808 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1809 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1810 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
|
1811 _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
|
1812 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1813 |
342 | 1814 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec, |
1815 double elapsed_ms) { | |
1816 _recent_gc_times_ms->add(elapsed_ms); | |
1817 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec); | |
1818 _prev_collection_pause_end_ms = end_time_sec * 1000.0; | |
1819 } | |
1820 | |
1821 size_t G1CollectorPolicy::expansion_amount() { | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1822 double recent_gc_overhead = recent_avg_pause_time_ratio() * 100.0; |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1823 double threshold = _gc_overhead_perc; |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1824 if (recent_gc_overhead > threshold) { |
751 | 1825 // We will double the existing space, or take |
1826 // G1ExpandByPercentOfAvailable % of the available expansion | |
1827 // space, whichever is smaller, bounded below by a minimum | |
1828 // expansion (unless that's all that's left.) | |
342 | 1829 const size_t min_expand_bytes = 1*M; |
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2152
diff
changeset
|
1830 size_t reserved_bytes = _g1->max_capacity(); |
342 | 1831 size_t committed_bytes = _g1->capacity(); |
1832 size_t uncommitted_bytes = reserved_bytes - committed_bytes; | |
1833 size_t expand_bytes; | |
1834 size_t expand_bytes_via_pct = | |
751 | 1835 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; |
342 | 1836 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); |
1837 expand_bytes = MAX2(expand_bytes, min_expand_bytes); | |
1838 expand_bytes = MIN2(expand_bytes, uncommitted_bytes); | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1839 |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1840 ergo_verbose5(ErgoHeapSizing, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1841 "attempt heap expansion", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1842 ergo_format_reason("recent GC overhead higher than " |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1843 "threshold after GC") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1844 ergo_format_perc("recent GC overhead") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1845 ergo_format_perc("threshold") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1846 ergo_format_byte("uncommitted") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1847 ergo_format_byte_perc("calculated expansion amount"), |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1848 recent_gc_overhead, threshold, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1849 uncommitted_bytes, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1850 expand_bytes_via_pct, (double) G1ExpandByPercentOfAvailable); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1851 |
342 | 1852 return expand_bytes; |
1853 } else { | |
1854 return 0; | |
1855 } | |
1856 } | |
1857 | |
1858 class CountCSClosure: public HeapRegionClosure { | |
1859 G1CollectorPolicy* _g1_policy; | |
1860 public: | |
1861 CountCSClosure(G1CollectorPolicy* g1_policy) : | |
1862 _g1_policy(g1_policy) {} | |
1863 bool doHeapRegion(HeapRegion* r) { | |
1864 _g1_policy->_bytes_in_collection_set_before_gc += r->used(); | |
1865 return false; | |
1866 } | |
1867 }; | |
1868 | |
1869 void G1CollectorPolicy::count_CS_bytes_used() { | |
1870 CountCSClosure cs_closure(this); | |
1871 _g1->collection_set_iterate(&cs_closure); | |
1872 } | |
1873 | |
4023 | 1874 void G1CollectorPolicy::print_summary(int level, |
1875 const char* str, | |
1876 NumberSeq* seq) const { | |
342 | 1877 double sum = seq->sum(); |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1878 LineBuffer(level + 1).append_and_print_cr("%-24s = %8.2lf s (avg = %8.2lf ms)", |
342 | 1879 str, sum / 1000.0, seq->avg()); |
1880 } | |
1881 | |
4023 | 1882 void G1CollectorPolicy::print_summary_sd(int level, |
1883 const char* str, | |
1884 NumberSeq* seq) const { | |
342 | 1885 print_summary(level, str, seq); |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1886 LineBuffer(level + 6).append_and_print_cr("(num = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", |
342 | 1887 seq->num(), seq->sd(), seq->maximum()); |
1888 } | |
1889 | |
1890 void G1CollectorPolicy::check_other_times(int level, | |
1891 NumberSeq* other_times_ms, | |
1892 NumberSeq* calc_other_times_ms) const { | |
1893 bool should_print = false; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1894 LineBuffer buf(level + 2); |
342 | 1895 |
1896 double max_sum = MAX2(fabs(other_times_ms->sum()), | |
1897 fabs(calc_other_times_ms->sum())); | |
1898 double min_sum = MIN2(fabs(other_times_ms->sum()), | |
1899 fabs(calc_other_times_ms->sum())); | |
1900 double sum_ratio = max_sum / min_sum; | |
1901 if (sum_ratio > 1.1) { | |
1902 should_print = true; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1903 buf.append_and_print_cr("## CALCULATED OTHER SUM DOESN'T MATCH RECORDED ###"); |
342 | 1904 } |
1905 | |
1906 double max_avg = MAX2(fabs(other_times_ms->avg()), | |
1907 fabs(calc_other_times_ms->avg())); | |
1908 double min_avg = MIN2(fabs(other_times_ms->avg()), | |
1909 fabs(calc_other_times_ms->avg())); | |
1910 double avg_ratio = max_avg / min_avg; | |
1911 if (avg_ratio > 1.1) { | |
1912 should_print = true; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1913 buf.append_and_print_cr("## CALCULATED OTHER AVG DOESN'T MATCH RECORDED ###"); |
342 | 1914 } |
1915 | |
1916 if (other_times_ms->sum() < -0.01) { | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1917 buf.append_and_print_cr("## RECORDED OTHER SUM IS NEGATIVE ###"); |
342 | 1918 } |
1919 | |
1920 if (other_times_ms->avg() < -0.01) { | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1921 buf.append_and_print_cr("## RECORDED OTHER AVG IS NEGATIVE ###"); |
342 | 1922 } |
1923 | |
1924 if (calc_other_times_ms->sum() < -0.01) { | |
1925 should_print = true; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1926 buf.append_and_print_cr("## CALCULATED OTHER SUM IS NEGATIVE ###"); |
342 | 1927 } |
1928 | |
1929 if (calc_other_times_ms->avg() < -0.01) { | |
1930 should_print = true; | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
1931 buf.append_and_print_cr("## CALCULATED OTHER AVG IS NEGATIVE ###"); |
342 | 1932 } |
1933 | |
1934 if (should_print) | |
1935 print_summary(level, "Other(Calc)", calc_other_times_ms); | |
1936 } | |
1937 | |
1938 void G1CollectorPolicy::print_summary(PauseSummary* summary) const { | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1939 bool parallel = G1CollectedHeap::use_parallel_gc_threads(); |
342 | 1940 MainBodySummary* body_summary = summary->main_body_summary(); |
1941 if (summary->get_total_seq()->num() > 0) { | |
677 | 1942 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq()); |
342 | 1943 if (body_summary != NULL) { |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1944 print_summary(1, "Root Region Scan Wait", body_summary->get_root_region_scan_wait_seq()); |
342 | 1945 if (parallel) { |
1946 print_summary(1, "Parallel Time", body_summary->get_parallel_seq()); | |
4023 | 1947 print_summary(2, "Ext Root Scanning", body_summary->get_ext_root_scan_seq()); |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1948 print_summary(2, "SATB Filtering", body_summary->get_satb_filtering_seq()); |
342 | 1949 print_summary(2, "Update RS", body_summary->get_update_rs_seq()); |
1950 print_summary(2, "Scan RS", body_summary->get_scan_rs_seq()); | |
1951 print_summary(2, "Object Copy", body_summary->get_obj_copy_seq()); | |
1952 print_summary(2, "Termination", body_summary->get_termination_seq()); | |
4023 | 1953 print_summary(2, "Parallel Other", body_summary->get_parallel_other_seq()); |
342 | 1954 { |
1955 NumberSeq* other_parts[] = { | |
1956 body_summary->get_ext_root_scan_seq(), | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1957 body_summary->get_satb_filtering_seq(), |
4023 | 1958 body_summary->get_update_rs_seq(), |
342 | 1959 body_summary->get_scan_rs_seq(), |
1960 body_summary->get_obj_copy_seq(), | |
1961 body_summary->get_termination_seq() | |
1962 }; | |
1963 NumberSeq calc_other_times_ms(body_summary->get_parallel_seq(), | |
1779 | 1964 6, other_parts); |
342 | 1965 check_other_times(2, body_summary->get_parallel_other_seq(), |
1966 &calc_other_times_ms); | |
1967 } | |
1968 } else { | |
4023 | 1969 print_summary(1, "Ext Root Scanning", body_summary->get_ext_root_scan_seq()); |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1970 print_summary(1, "SATB Filtering", body_summary->get_satb_filtering_seq()); |
342 | 1971 print_summary(1, "Update RS", body_summary->get_update_rs_seq()); |
1972 print_summary(1, "Scan RS", body_summary->get_scan_rs_seq()); | |
1973 print_summary(1, "Object Copy", body_summary->get_obj_copy_seq()); | |
1974 } | |
1975 } | |
4023 | 1976 print_summary(1, "Mark Closure", body_summary->get_mark_closure_seq()); |
1977 print_summary(1, "Clear CT", body_summary->get_clear_ct_seq()); | |
342 | 1978 print_summary(1, "Other", summary->get_other_seq()); |
1979 { | |
1779 | 1980 if (body_summary != NULL) { |
1981 NumberSeq calc_other_times_ms; | |
1982 if (parallel) { | |
1983 // parallel | |
1984 NumberSeq* other_parts[] = { | |
1985 body_summary->get_satb_drain_seq(), | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1986 body_summary->get_root_region_scan_wait_seq(), |
1779 | 1987 body_summary->get_parallel_seq(), |
1988 body_summary->get_clear_ct_seq() | |
1989 }; | |
1990 calc_other_times_ms = NumberSeq(summary->get_total_seq(), | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1991 4, other_parts); |
1779 | 1992 } else { |
1993 // serial | |
1994 NumberSeq* other_parts[] = { | |
1995 body_summary->get_satb_drain_seq(), | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
1996 body_summary->get_root_region_scan_wait_seq(), |
1779 | 1997 body_summary->get_update_rs_seq(), |
1998 body_summary->get_ext_root_scan_seq(), | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4729
diff
changeset
|
1999 body_summary->get_satb_filtering_seq(), |
1779 | 2000 body_summary->get_scan_rs_seq(), |
2001 body_summary->get_obj_copy_seq() | |
2002 }; | |
2003 calc_other_times_ms = NumberSeq(summary->get_total_seq(), | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
2004 7, other_parts); |
1779 | 2005 } |
2006 check_other_times(1, summary->get_other_seq(), &calc_other_times_ms); | |
342 | 2007 } |
2008 } | |
2009 } else { | |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
2010 LineBuffer(1).append_and_print_cr("none"); |
342 | 2011 } |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
2012 LineBuffer(0).append_and_print_cr(""); |
342 | 2013 } |
2014 | |
2015 void G1CollectorPolicy::print_tracing_info() const { | |
2016 if (TraceGen0Time) { | |
2017 gclog_or_tty->print_cr("ALL PAUSES"); | |
2018 print_summary_sd(0, "Total", _all_pause_times_ms); | |
2019 gclog_or_tty->print_cr(""); | |
2020 gclog_or_tty->print_cr(""); | |
4710 | 2021 gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); |
2022 gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); | |
342 | 2023 gclog_or_tty->print_cr(""); |
2024 | |
677 | 2025 gclog_or_tty->print_cr("EVACUATION PAUSES"); |
2026 print_summary(_summary); | |
342 | 2027 |
2028 gclog_or_tty->print_cr("MISC"); | |
2029 print_summary_sd(0, "Stop World", _all_stop_world_times_ms); | |
2030 print_summary_sd(0, "Yields", _all_yield_times_ms); | |
2031 for (int i = 0; i < _aux_num; ++i) { | |
2032 if (_all_aux_times_ms[i].num() > 0) { | |
2033 char buffer[96]; | |
2034 sprintf(buffer, "Aux%d", i); | |
2035 print_summary_sd(0, buffer, &_all_aux_times_ms[i]); | |
2036 } | |
2037 } | |
2038 } | |
2039 if (TraceGen1Time) { | |
2040 if (_all_full_gc_times_ms->num() > 0) { | |
2041 gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", | |
2042 _all_full_gc_times_ms->num(), | |
2043 _all_full_gc_times_ms->sum() / 1000.0); | |
2044 gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times_ms->avg()); | |
2045 gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", | |
2046 _all_full_gc_times_ms->sd(), | |
2047 _all_full_gc_times_ms->maximum()); | |
2048 } | |
2049 } | |
2050 } | |
2051 | |
2052 void G1CollectorPolicy::print_yg_surv_rate_info() const { | |
2053 #ifndef PRODUCT | |
2054 _short_lived_surv_rate_group->print_surv_rate_summary(); | |
2055 // add this call for any other surv rate groups | |
2056 #endif // PRODUCT | |
2057 } | |
2058 | |
2059 #ifndef PRODUCT | |
2060 // for debugging, bit of a hack... | |
2061 static char* | |
2062 region_num_to_mbs(int length) { | |
2063 static char buffer[64]; | |
2064 double bytes = (double) (length * HeapRegion::GrainBytes); | |
2065 double mbs = bytes / (double) (1024 * 1024); | |
2066 sprintf(buffer, "%7.2lfMB", mbs); | |
2067 return buffer; | |
2068 } | |
2069 #endif // PRODUCT | |
2070 | |
545 | 2071 size_t G1CollectorPolicy::max_regions(int purpose) { |
342 | 2072 switch (purpose) { |
2073 case GCAllocForSurvived: | |
545 | 2074 return _max_survivor_regions; |
342 | 2075 case GCAllocForTenured: |
545 | 2076 return REGIONS_UNLIMITED; |
342 | 2077 default: |
545 | 2078 ShouldNotReachHere(); |
2079 return REGIONS_UNLIMITED; | |
342 | 2080 }; |
2081 } | |
2082 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2083 void G1CollectorPolicy::update_max_gc_locker_expansion() { |
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2084 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
|
2085 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
|
2086 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
|
2087 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
|
2088 // 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
|
2089 // 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
|
2090 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
|
2091 } else { |
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2092 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
|
2093 } |
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2094 _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
|
2095 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
|
2096 } |
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
2097 |
545 | 2098 // Calculates survivor space parameters. |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2099 void G1CollectorPolicy::update_survivors_policy() { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2100 double max_survivor_regions_d = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2101 (double) _young_list_target_length / (double) SurvivorRatio; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2102 // We use ceiling so that if max_survivor_regions_d is > 0.0 (but |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2103 // smaller than 1.0) we'll get 1. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2104 _max_survivor_regions = (size_t) ceil(max_survivor_regions_d); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
2105 |
3868
ae73da50be4b
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
3867
diff
changeset
|
2106 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( |
545 | 2107 HeapRegion::GrainWords * _max_survivor_regions); |
2108 } | |
2109 | |
342 | 2110 #ifndef PRODUCT |
2111 class HRSortIndexIsOKClosure: public HeapRegionClosure { | |
2112 CollectionSetChooser* _chooser; | |
2113 public: | |
2114 HRSortIndexIsOKClosure(CollectionSetChooser* chooser) : | |
2115 _chooser(chooser) {} | |
2116 | |
2117 bool doHeapRegion(HeapRegion* r) { | |
2118 if (!r->continuesHumongous()) { | |
2119 assert(_chooser->regionProperlyOrdered(r), "Ought to be."); | |
2120 } | |
2121 return false; | |
2122 } | |
2123 }; | |
2124 | |
4013 | 2125 bool G1CollectorPolicy::assertMarkedBytesDataOK() { |
342 | 2126 HRSortIndexIsOKClosure cl(_collectionSetChooser); |
2127 _g1->heap_region_iterate(&cl); | |
2128 return true; | |
2129 } | |
2130 #endif | |
2131 | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2132 bool G1CollectorPolicy::force_initial_mark_if_outside_cycle( |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2133 GCCause::Cause gc_cause) { |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2134 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2135 if (!during_cycle) { |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2136 ergo_verbose1(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2137 "request concurrent cycle initiation", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2138 ergo_format_reason("requested by GC cause") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2139 ergo_format_str("GC cause"), |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2140 GCCause::to_string(gc_cause)); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2141 set_initiate_conc_mark_if_possible(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2142 return true; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2143 } else { |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2144 ergo_verbose1(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2145 "do not request concurrent cycle initiation", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2146 ergo_format_reason("concurrent cycle already in progress") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2147 ergo_format_str("GC cause"), |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2148 GCCause::to_string(gc_cause)); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2149 return false; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2150 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2151 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2152 |
342 | 2153 void |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2154 G1CollectorPolicy::decide_on_conc_mark_initiation() { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2155 // 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
|
2156 // initial-mark pause. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2157 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2158 // 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
|
2159 // 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
|
2160 // 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
|
2161 // initial-mark pause). |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2162 assert(!during_initial_mark_pause(), "pre-condition"); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2163 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2164 if (initiate_conc_mark_if_possible()) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2165 // 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
|
2166 // 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
|
2167 // concurrent marking cycle. So we might initiate one. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2168 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2169 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2170 if (!during_cycle) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2171 // 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
|
2172 // 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
|
2173 // initiate a new cycle. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2174 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2175 set_during_initial_mark_pause(); |
4710 | 2176 // We do not allow mixed GCs during marking. |
2177 if (!gcs_are_young()) { | |
2178 set_gcs_are_young(true); | |
2179 ergo_verbose0(ErgoMixedGCs, | |
2180 "end mixed GCs", | |
3982
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3979
diff
changeset
|
2181 ergo_format_reason("concurrent cycle is about to start")); |
273b46400613
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
3979
diff
changeset
|
2182 } |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2183 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2184 // 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
|
2185 // we've already acted on it. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2186 clear_initiate_conc_mark_if_possible(); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2187 |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2188 ergo_verbose0(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2189 "initiate concurrent cycle", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2190 ergo_format_reason("concurrent cycle initiation requested")); |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2191 } else { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2192 // The concurrent marking thread is still finishing up the |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2193 // 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
|
2194 // overlap. In particular, the concurrent marking thread might |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2195 // 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
|
2196 // 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
|
2197 // 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
|
2198 // 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
|
2199 // 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
|
2200 // periodically yields while clearing the next marking bitmap |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2201 // 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
|
2202 // 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
|
2203 // let the concurrent marking thread complete the last one. |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2204 ergo_verbose0(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2205 "do not initiate concurrent cycle", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2206 ergo_format_reason("concurrent cycle already in progress")); |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2207 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2208 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2209 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
2210 |
342 | 2211 class KnownGarbageClosure: public HeapRegionClosure { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2212 G1CollectedHeap* _g1h; |
342 | 2213 CollectionSetChooser* _hrSorted; |
2214 | |
2215 public: | |
2216 KnownGarbageClosure(CollectionSetChooser* hrSorted) : | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2217 _g1h(G1CollectedHeap::heap()), _hrSorted(hrSorted) { } |
342 | 2218 |
2219 bool doHeapRegion(HeapRegion* r) { | |
2220 // We only include humongous regions in collection | |
2221 // sets when concurrent mark shows that their contained object is | |
2222 // unreachable. | |
2223 | |
2224 // Do we have any marking information for this region? | |
2225 if (r->is_marked()) { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2226 // We will skip any region that's currently used as an old GC |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2227 // alloc region (we should not consider those for collection |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2228 // before we fill them up). |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2229 if (_hrSorted->shouldAdd(r) && !_g1h->is_old_gc_alloc_region(r)) { |
342 | 2230 _hrSorted->addMarkedHeapRegion(r); |
2231 } | |
2232 } | |
2233 return false; | |
2234 } | |
2235 }; | |
2236 | |
2237 class ParKnownGarbageHRClosure: public HeapRegionClosure { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2238 G1CollectedHeap* _g1h; |
342 | 2239 CollectionSetChooser* _hrSorted; |
2240 jint _marked_regions_added; | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2241 size_t _reclaimable_bytes_added; |
342 | 2242 jint _chunk_size; |
2243 jint _cur_chunk_idx; | |
2244 jint _cur_chunk_end; // Cur chunk [_cur_chunk_idx, _cur_chunk_end) | |
2245 int _worker; | |
2246 int _invokes; | |
2247 | |
2248 void get_new_chunk() { | |
2249 _cur_chunk_idx = _hrSorted->getParMarkedHeapRegionChunk(_chunk_size); | |
2250 _cur_chunk_end = _cur_chunk_idx + _chunk_size; | |
2251 } | |
2252 void add_region(HeapRegion* r) { | |
2253 if (_cur_chunk_idx == _cur_chunk_end) { | |
2254 get_new_chunk(); | |
2255 } | |
2256 assert(_cur_chunk_idx < _cur_chunk_end, "postcondition"); | |
2257 _hrSorted->setMarkedHeapRegion(_cur_chunk_idx, r); | |
2258 _marked_regions_added++; | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2259 _reclaimable_bytes_added += r->reclaimable_bytes(); |
342 | 2260 _cur_chunk_idx++; |
2261 } | |
2262 | |
2263 public: | |
2264 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, | |
2265 jint chunk_size, | |
2266 int worker) : | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2267 _g1h(G1CollectedHeap::heap()), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2268 _hrSorted(hrSorted), _chunk_size(chunk_size), _worker(worker), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2269 _marked_regions_added(0), _reclaimable_bytes_added(0), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2270 _cur_chunk_idx(0), _cur_chunk_end(0), _invokes(0) { } |
342 | 2271 |
2272 bool doHeapRegion(HeapRegion* r) { | |
2273 // We only include humongous regions in collection | |
2274 // sets when concurrent mark shows that their contained object is | |
2275 // unreachable. | |
2276 _invokes++; | |
2277 | |
2278 // Do we have any marking information for this region? | |
2279 if (r->is_marked()) { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2280 // We will skip any region that's currently used as an old GC |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2281 // alloc region (we should not consider those for collection |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2282 // before we fill them up). |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2283 if (_hrSorted->shouldAdd(r) && !_g1h->is_old_gc_alloc_region(r)) { |
342 | 2284 add_region(r); |
2285 } | |
2286 } | |
2287 return false; | |
2288 } | |
2289 jint marked_regions_added() { return _marked_regions_added; } | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2290 size_t reclaimable_bytes_added() { return _reclaimable_bytes_added; } |
342 | 2291 int invokes() { return _invokes; } |
2292 }; | |
2293 | |
2294 class ParKnownGarbageTask: public AbstractGangTask { | |
2295 CollectionSetChooser* _hrSorted; | |
2296 jint _chunk_size; | |
2297 G1CollectedHeap* _g1; | |
2298 public: | |
2299 ParKnownGarbageTask(CollectionSetChooser* hrSorted, jint chunk_size) : | |
2300 AbstractGangTask("ParKnownGarbageTask"), | |
2301 _hrSorted(hrSorted), _chunk_size(chunk_size), | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2302 _g1(G1CollectedHeap::heap()) { } |
342 | 2303 |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
2304 void work(uint worker_id) { |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
2305 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
2306 _chunk_size, |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
2307 worker_id); |
342 | 2308 // Back to zero for the claim value. |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
2309 _g1->heap_region_par_iterate_chunked(&parKnownGarbageCl, worker_id, |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2310 _g1->workers()->active_workers(), |
355 | 2311 HeapRegion::InitialClaimValue); |
342 | 2312 jint regions_added = parKnownGarbageCl.marked_regions_added(); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2313 size_t reclaimable_bytes_added = |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2314 parKnownGarbageCl.reclaimable_bytes_added(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2315 _hrSorted->updateTotals(regions_added, reclaimable_bytes_added); |
342 | 2316 if (G1PrintParCleanupStats) { |
2363
c93aa6caa02f
7022943: G1: improve logging to avoid interleaved numbers
brutisso
parents:
2188
diff
changeset
|
2317 gclog_or_tty->print_cr(" Thread %d called %d times, added %d regions to list.", |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
2318 worker_id, parKnownGarbageCl.invokes(), regions_added); |
342 | 2319 } |
2320 } | |
2321 }; | |
2322 | |
2323 void | |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2324 G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) { |
4013 | 2325 double start_sec; |
2326 if (G1PrintParCleanupStats) { | |
2327 start_sec = os::elapsedTime(); | |
2328 } | |
342 | 2329 |
2330 _collectionSetChooser->clearMarkedHeapRegions(); | |
4013 | 2331 double clear_marked_end_sec; |
342 | 2332 if (G1PrintParCleanupStats) { |
4013 | 2333 clear_marked_end_sec = os::elapsedTime(); |
2334 gclog_or_tty->print_cr(" clear marked regions: %8.3f ms.", | |
2335 (clear_marked_end_sec - start_sec) * 1000.0); | |
342 | 2336 } |
4013 | 2337 |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
2338 if (G1CollectedHeap::use_parallel_gc_threads()) { |
342 | 2339 const size_t OverpartitionFactor = 4; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2340 size_t WorkUnit; |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2341 // The use of MinChunkSize = 8 in the original code |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2342 // causes some assertion failures when the total number of |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2343 // region is less than 8. The code here tries to fix that. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2344 // Should the original code also be fixed? |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2345 if (no_of_gc_threads > 0) { |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2346 const size_t MinWorkUnit = |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2347 MAX2(_g1->n_regions() / no_of_gc_threads, (size_t) 1U); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2348 WorkUnit = |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2349 MAX2(_g1->n_regions() / (no_of_gc_threads * OverpartitionFactor), |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2350 MinWorkUnit); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2351 } else { |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2352 assert(no_of_gc_threads > 0, |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2353 "The active gc workers should be greater than 0"); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2354 // In a product build do something reasonable to avoid a crash. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2355 const size_t MinWorkUnit = |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2356 MAX2(_g1->n_regions() / ParallelGCThreads, (size_t) 1U); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2357 WorkUnit = |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2358 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2359 MinWorkUnit); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2360 } |
342 | 2361 _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
|
2362 WorkUnit); |
342 | 2363 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
|
2364 (int) WorkUnit); |
342 | 2365 _g1->workers()->run_task(&parKnownGarbageTask); |
355 | 2366 |
2367 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
2368 "sanity check"); | |
342 | 2369 } else { |
2370 KnownGarbageClosure knownGarbagecl(_collectionSetChooser); | |
2371 _g1->heap_region_iterate(&knownGarbagecl); | |
2372 } | |
4013 | 2373 double known_garbage_end_sec; |
342 | 2374 if (G1PrintParCleanupStats) { |
4013 | 2375 known_garbage_end_sec = os::elapsedTime(); |
342 | 2376 gclog_or_tty->print_cr(" compute known garbage: %8.3f ms.", |
4013 | 2377 (known_garbage_end_sec - clear_marked_end_sec) * 1000.0); |
342 | 2378 } |
4013 | 2379 |
342 | 2380 _collectionSetChooser->sortMarkedHeapRegions(); |
4013 | 2381 double end_sec = os::elapsedTime(); |
342 | 2382 if (G1PrintParCleanupStats) { |
2383 gclog_or_tty->print_cr(" sorting: %8.3f ms.", | |
4013 | 2384 (end_sec - known_garbage_end_sec) * 1000.0); |
342 | 2385 } |
2386 | |
4013 | 2387 double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0; |
2388 _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); | |
2389 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
2390 _prev_collection_pause_end_ms += elapsed_time_ms; | |
2391 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec, true); | |
342 | 2392 } |
2393 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2394 // Add the heap region at the head of the non-incremental collection set |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2395 void G1CollectorPolicy::add_old_region_to_cset(HeapRegion* hr) { |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2396 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
|
2397 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
|
2398 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2399 assert(!hr->in_collection_set(), "should not already be in the CSet"); |
342 | 2400 hr->set_in_collection_set(true); |
2401 hr->set_next_in_collection_set(_collection_set); | |
2402 _collection_set = hr; | |
2403 _collection_set_bytes_used_before += hr->used(); | |
526 | 2404 _g1->register_region_with_in_cset_fast_test(hr); |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2405 size_t rs_length = hr->rem_set()->occupied(); |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2406 _recorded_rs_lengths += rs_length; |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2407 _old_cset_region_length += 1; |
342 | 2408 } |
2409 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2410 // 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
|
2411 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
|
2412 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
|
2413 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2414 _inc_cset_head = NULL; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2415 _inc_cset_tail = NULL; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2416 _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
|
2417 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2418 _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
|
2419 _inc_cset_recorded_rs_lengths = 0; |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2420 _inc_cset_recorded_rs_lengths_diffs = 0; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2421 _inc_cset_predicted_elapsed_time_ms = 0.0; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2422 _inc_cset_predicted_elapsed_time_ms_diffs = 0.0; |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2423 _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
|
2424 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2425 |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2426 void G1CollectorPolicy::finalize_incremental_cset_building() { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2427 assert(_inc_cset_build_state == Active, "Precondition"); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2428 assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint"); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2429 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2430 // The two "main" fields, _inc_cset_recorded_rs_lengths and |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2431 // _inc_cset_predicted_elapsed_time_ms, are updated by the thread |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2432 // that adds a new region to the CSet. Further updates by the |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2433 // concurrent refinement thread that samples the young RSet lengths |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2434 // are accumulated in the *_diffs fields. Here we add the diffs to |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2435 // the "main" fields. |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2436 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2437 if (_inc_cset_recorded_rs_lengths_diffs >= 0) { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2438 _inc_cset_recorded_rs_lengths += _inc_cset_recorded_rs_lengths_diffs; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2439 } else { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2440 // This is defensive. The diff should in theory be always positive |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2441 // as RSets can only grow between GCs. However, given that we |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2442 // sample their size concurrently with other threads updating them |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2443 // it's possible that we might get the wrong size back, which |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2444 // could make the calculations somewhat inaccurate. |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2445 size_t diffs = (size_t) (-_inc_cset_recorded_rs_lengths_diffs); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2446 if (_inc_cset_recorded_rs_lengths >= diffs) { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2447 _inc_cset_recorded_rs_lengths -= diffs; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2448 } else { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2449 _inc_cset_recorded_rs_lengths = 0; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2450 } |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2451 } |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2452 _inc_cset_predicted_elapsed_time_ms += |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2453 _inc_cset_predicted_elapsed_time_ms_diffs; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2454 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2455 _inc_cset_recorded_rs_lengths_diffs = 0; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2456 _inc_cset_predicted_elapsed_time_ms_diffs = 0.0; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2457 } |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2458 |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2459 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
|
2460 // 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
|
2461 // * 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
|
2462 // evacuation pause, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2463 // * 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
|
2464 // 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
|
2465 // * 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
|
2466 // 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
|
2467 // 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
|
2468 // 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
|
2469 // 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
|
2470 // refine thread (RSet sampling). |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2471 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2472 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
|
2473 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
|
2474 _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
|
2475 _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
|
2476 _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
|
2477 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2478 // 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
|
2479 // 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
|
2480 // 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
|
2481 // rset sampling code |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2482 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
|
2483 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
|
2484 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2485 |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2486 void G1CollectorPolicy::update_incremental_cset_info(HeapRegion* hr, |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2487 size_t new_rs_length) { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2488 // Update the CSet information that is dependent on the new RS length |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2489 assert(hr->is_young(), "Precondition"); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2490 assert(!SafepointSynchronize::is_at_safepoint(), |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2491 "should not be at a safepoint"); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2492 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2493 // We could have updated _inc_cset_recorded_rs_lengths and |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2494 // _inc_cset_predicted_elapsed_time_ms directly but we'd need to do |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2495 // that atomically, as this code is executed by a concurrent |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2496 // refinement thread, potentially concurrently with a mutator thread |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2497 // allocating a new region and also updating the same fields. To |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2498 // avoid the atomic operations we accumulate these updates on two |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2499 // separate fields (*_diffs) and we'll just add them to the "main" |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2500 // fields at the start of a GC. |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2501 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2502 ssize_t old_rs_length = (ssize_t) hr->recorded_rs_length(); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2503 ssize_t rs_lengths_diff = (ssize_t) new_rs_length - old_rs_length; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2504 _inc_cset_recorded_rs_lengths_diffs += rs_lengths_diff; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2505 |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2506 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms(); |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2507 double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, true); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2508 double elapsed_ms_diff = new_region_elapsed_time_ms - old_elapsed_time_ms; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2509 _inc_cset_predicted_elapsed_time_ms_diffs += elapsed_ms_diff; |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2510 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2511 hr->set_recorded_rs_length(new_rs_length); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2512 hr->set_predicted_elapsed_time_ms(new_region_elapsed_time_ms); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2513 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2514 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2515 void G1CollectorPolicy::add_region_to_incremental_cset_common(HeapRegion* hr) { |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2516 assert(hr->is_young(), "invariant"); |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2517 assert(hr->young_index_in_cset() > -1, "should have already been set"); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2518 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
|
2519 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2520 // 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
|
2521 // 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
|
2522 // 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
|
2523 // 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
|
2524 // 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
|
2525 // 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
|
2526 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2527 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
|
2528 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
|
2529 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2530 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
|
2531 _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
|
2532 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2533 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
|
2534 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
|
2535 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
|
2536 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2537 _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
|
2538 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2539 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2540 // 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
|
2541 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
|
2542 // 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
|
2543 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
|
2544 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2545 // Do the 'common' stuff |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2546 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
|
2547 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2548 // 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
|
2549 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
|
2550 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
|
2551 _inc_cset_head = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2552 } else { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2553 _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
|
2554 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2555 _inc_cset_tail = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2556 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2557 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2558 // 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
|
2559 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
|
2560 // 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
|
2561 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
|
2562 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2563 // Do the 'common' stuff |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2564 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
|
2565 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2566 // 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
|
2567 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
|
2568 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
|
2569 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
|
2570 _inc_cset_tail = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2571 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2572 _inc_cset_head = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2573 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2574 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2575 #ifndef PRODUCT |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2576 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
|
2577 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
|
2578 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2579 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
|
2580 HeapRegion* csr = list_head; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2581 while (csr != NULL) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2582 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
|
2583 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
|
2584 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
|
2585 "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
|
2586 csr->bottom(), csr->end(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2587 csr->top(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2588 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
|
2589 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
|
2590 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
|
2591 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
|
2592 csr->is_young(), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2593 csr->is_survivor()); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2594 csr = next; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2595 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2596 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2597 #endif // !PRODUCT |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2598 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2599 bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2600 const char* false_action_str) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2601 CollectionSetChooser* cset_chooser = _collectionSetChooser; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2602 if (cset_chooser->isEmpty()) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2603 ergo_verbose0(ErgoMixedGCs, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2604 false_action_str, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2605 ergo_format_reason("candidate old regions not available")); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2606 return false; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2607 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2608 size_t reclaimable_bytes = cset_chooser->remainingReclaimableBytes(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2609 size_t capacity_bytes = _g1->capacity(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2610 double perc = (double) reclaimable_bytes * 100.0 / (double) capacity_bytes; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2611 double threshold = (double) G1OldReclaimableThresholdPercent; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2612 if (perc < threshold) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2613 ergo_verbose4(ErgoMixedGCs, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2614 false_action_str, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2615 ergo_format_reason("reclaimable percentage lower than threshold") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2616 ergo_format_region("candidate old regions") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2617 ergo_format_byte_perc("reclaimable") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2618 ergo_format_perc("threshold"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2619 cset_chooser->remainingRegions(), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2620 reclaimable_bytes, perc, threshold); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2621 return false; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2622 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2623 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2624 ergo_verbose4(ErgoMixedGCs, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2625 true_action_str, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2626 ergo_format_reason("candidate old regions available") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2627 ergo_format_region("candidate old regions") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2628 ergo_format_byte_perc("reclaimable") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2629 ergo_format_perc("threshold"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2630 cset_chooser->remainingRegions(), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2631 reclaimable_bytes, perc, threshold); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2632 return true; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2633 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2634 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2635 void G1CollectorPolicy::finalize_cset(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
|
2636 // 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
|
2637 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
|
2638 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2639 YoungList* young_list = _g1->young_list(); |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
2640 finalize_incremental_cset_building(); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2641 |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2642 guarantee(target_pause_time_ms > 0.0, |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2643 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
|
2644 target_pause_time_ms)); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2645 guarantee(_collection_set == NULL, "Precondition"); |
342 | 2646 |
2647 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); | |
2648 double predicted_pause_time_ms = base_time_ms; | |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2649 double time_remaining_ms = target_pause_time_ms - base_time_ms; |
342 | 2650 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2651 ergo_verbose3(ErgoCSetConstruction | ErgoHigh, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2652 "start choosing CSet", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2653 ergo_format_ms("predicted base time") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2654 ergo_format_ms("remaining time") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2655 ergo_format_ms("target pause time"), |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2656 base_time_ms, time_remaining_ms, target_pause_time_ms); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2657 |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2658 HeapRegion* hr; |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2659 double young_start_time_sec = os::elapsedTime(); |
342 | 2660 |
677 | 2661 _collection_set_bytes_used_before = 0; |
4710 | 2662 _last_gc_was_young = gcs_are_young() ? true : false; |
2663 | |
2664 if (_last_gc_was_young) { | |
2665 ++_young_pause_num; | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2666 } else { |
4710 | 2667 ++_mixed_pause_num; |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2668 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2669 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2670 // The young list is laid with the survivor regions from the previous |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2671 // pause are appended to the RHS of the young list, i.e. |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2672 // [Newly Young Regions ++ Survivors from last pause]. |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2673 |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2674 size_t survivor_region_length = young_list->survivor_length(); |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2675 size_t eden_region_length = young_list->length() - survivor_region_length; |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2676 init_cset_region_lengths(eden_region_length, survivor_region_length); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2677 hr = young_list->first_survivor_region(); |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2678 while (hr != NULL) { |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2679 assert(hr->is_survivor(), "badly formed young list"); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2680 hr->set_young(); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2681 hr = hr->get_next_young_region(); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2682 } |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2683 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2684 // Clear the fields that point to the survivor list - they are all young now. |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2685 young_list->clear_survivors(); |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2686 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2687 _collection_set = _inc_cset_head; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2688 _collection_set_bytes_used_before = _inc_cset_bytes_used_before; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2689 time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2690 predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2691 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2692 ergo_verbose3(ErgoCSetConstruction | ErgoHigh, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2693 "add young regions to CSet", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2694 ergo_format_region("eden") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2695 ergo_format_region("survivors") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2696 ergo_format_ms("predicted young region time"), |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2697 eden_region_length, survivor_region_length, |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2698 _inc_cset_predicted_elapsed_time_ms); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2699 |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2700 // The number of recorded young regions is the incremental |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2701 // collection set's current size |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2702 set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2703 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2704 double young_end_time_sec = os::elapsedTime(); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2705 _recorded_young_cset_choice_time_ms = |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2706 (young_end_time_sec - young_start_time_sec) * 1000.0; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2707 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2708 // We are doing young collections so reset this. |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2709 non_young_start_time_sec = young_end_time_sec; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
2710 |
4710 | 2711 if (!gcs_are_young()) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2712 CollectionSetChooser* cset_chooser = _collectionSetChooser; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2713 assert(cset_chooser->verify(), "CSet Chooser verification - pre"); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2714 const size_t min_old_cset_length = cset_chooser->calcMinOldCSetLength(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2715 const size_t max_old_cset_length = cset_chooser->calcMaxOldCSetLength(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2716 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2717 size_t expensive_region_num = 0; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2718 bool check_time_remaining = adaptive_young_list_length(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2719 HeapRegion* hr = cset_chooser->peek(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2720 while (hr != NULL) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2721 if (old_cset_region_length() >= max_old_cset_length) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2722 // Added maximum number of old regions to the CSet. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2723 ergo_verbose2(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2724 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2725 ergo_format_reason("old CSet region num reached max") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2726 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2727 ergo_format_region("max"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2728 old_cset_region_length(), max_old_cset_length); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2729 break; |
342 | 2730 } |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2731 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2732 double predicted_time_ms = predict_region_elapsed_time_ms(hr, false); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2733 if (check_time_remaining) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2734 if (predicted_time_ms > time_remaining_ms) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2735 // Too expensive for the current CSet. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2736 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2737 if (old_cset_region_length() >= min_old_cset_length) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2738 // We have added the minimum number of old regions to the CSet, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2739 // we are done with this CSet. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2740 ergo_verbose4(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2741 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2742 ergo_format_reason("predicted time is too high") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2743 ergo_format_ms("predicted time") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2744 ergo_format_ms("remaining time") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2745 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2746 ergo_format_region("min"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2747 predicted_time_ms, time_remaining_ms, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2748 old_cset_region_length(), min_old_cset_length); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2749 break; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2750 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2751 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2752 // We'll add it anyway given that we haven't reached the |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2753 // minimum number of old regions. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2754 expensive_region_num += 1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2755 } |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2756 } else { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2757 if (old_cset_region_length() >= min_old_cset_length) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2758 // In the non-auto-tuning case, we'll finish adding regions |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2759 // to the CSet if we reach the minimum. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2760 ergo_verbose2(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2761 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2762 ergo_format_reason("old CSet region num reached min") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2763 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2764 ergo_format_region("min"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2765 old_cset_region_length(), min_old_cset_length); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2766 break; |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2767 } |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2768 } |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2769 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2770 // We will add this region to the CSet. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2771 time_remaining_ms -= predicted_time_ms; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2772 predicted_pause_time_ms += predicted_time_ms; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2773 cset_chooser->remove_and_move_to_next(hr); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2774 _g1->old_set_remove(hr); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2775 add_old_region_to_cset(hr); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2776 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2777 hr = cset_chooser->peek(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2778 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2779 if (hr == NULL) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2780 ergo_verbose0(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2781 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2782 ergo_format_reason("candidate old regions not available")); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2783 } |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2784 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2785 if (expensive_region_num > 0) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2786 // We print the information once here at the end, predicated on |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2787 // whether we added any apparently expensive regions or not, to |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2788 // avoid generating output per region. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2789 ergo_verbose4(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2790 "added expensive regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2791 ergo_format_reason("old CSet region num not reached min") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2792 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2793 ergo_format_region("expensive") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2794 ergo_format_region("min") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2795 ergo_format_ms("remaining time"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2796 old_cset_region_length(), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2797 expensive_region_num, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2798 min_old_cset_length, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2799 time_remaining_ms); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2800 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2801 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2802 assert(cset_chooser->verify(), "CSet Chooser verification - post"); |
342 | 2803 } |
2804 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2805 stop_incremental_cset_building(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2806 |
342 | 2807 count_CS_bytes_used(); |
2808 | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2809 ergo_verbose5(ErgoCSetConstruction, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2810 "finish choosing CSet", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2811 ergo_format_region("eden") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2812 ergo_format_region("survivors") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2813 ergo_format_region("old") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2814 ergo_format_ms("predicted pause time") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2815 ergo_format_ms("target pause time"), |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2816 eden_region_length, survivor_region_length, |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
2817 old_cset_region_length(), |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2818 predicted_pause_time_ms, target_pause_time_ms); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2819 |
342 | 2820 double non_young_end_time_sec = os::elapsedTime(); |
2821 _recorded_non_young_cset_choice_time_ms = | |
2822 (non_young_end_time_sec - non_young_start_time_sec) * 1000.0; | |
2823 } |