Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
author | tamao |
---|---|
date | Tue, 05 Mar 2013 15:36:56 -0800 |
parents | 27714220e50e |
children | cc32ccaaf47f 71013d764f6e |
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" |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
32 #include "gc_implementation/g1/g1GCPhaseTimes.hpp" |
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5988
diff
changeset
|
33 #include "gc_implementation/g1/g1Log.hpp" |
1972 | 34 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
35 #include "gc_implementation/shared/gcPolicyCounters.hpp" | |
36 #include "runtime/arguments.hpp" | |
37 #include "runtime/java.hpp" | |
38 #include "runtime/mutexLocker.hpp" | |
39 #include "utilities/debug.hpp" | |
342 | 40 |
41 // Different defaults for different number of GC threads | |
42 // They were chosen by running GCOld and SPECjbb on debris with different | |
43 // numbers of GC threads and choosing them based on the results | |
44 | |
45 // all the same | |
46 static double rs_length_diff_defaults[] = { | |
47 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 | |
48 }; | |
49 | |
50 static double cost_per_card_ms_defaults[] = { | |
51 0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015 | |
52 }; | |
53 | |
54 // all the same | |
4710 | 55 static double young_cards_per_entry_ratio_defaults[] = { |
342 | 56 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 |
57 }; | |
58 | |
59 static double cost_per_entry_ms_defaults[] = { | |
60 0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005 | |
61 }; | |
62 | |
63 static double cost_per_byte_ms_defaults[] = { | |
64 0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009 | |
65 }; | |
66 | |
67 // these should be pretty consistent | |
68 static double constant_other_time_ms_defaults[] = { | |
69 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 | |
70 }; | |
71 | |
72 | |
73 static double young_other_cost_per_region_ms_defaults[] = { | |
74 0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1 | |
75 }; | |
76 | |
77 static double non_young_other_cost_per_region_ms_defaults[] = { | |
78 1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 | |
79 }; | |
80 | |
81 G1CollectorPolicy::G1CollectorPolicy() : | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
82 _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
|
83 ? ParallelGCThreads : 1), |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
84 |
342 | 85 _recent_gc_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
86 _stop_world_start(0.0), | |
87 | |
88 _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
89 _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), | |
90 | |
91 _alloc_rate_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
92 _prev_collection_pause_end_ms(0.0), | |
93 _rs_length_diff_seq(new TruncatedSeq(TruncatedSeqLength)), | |
94 _cost_per_card_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
4710 | 95 _young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), |
96 _mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), | |
342 | 97 _cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
4710 | 98 _mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
342 | 99 _cost_per_byte_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
100 _cost_per_byte_ms_during_cm_seq(new TruncatedSeq(TruncatedSeqLength)), | |
101 _constant_other_time_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
102 _young_other_cost_per_region_ms_seq(new TruncatedSeq(TruncatedSeqLength)), | |
103 _non_young_other_cost_per_region_ms_seq( | |
104 new TruncatedSeq(TruncatedSeqLength)), | |
105 | |
106 _pending_cards_seq(new TruncatedSeq(TruncatedSeqLength)), | |
107 _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)), | |
108 | |
751 | 109 _pause_time_target_ms((double) MaxGCPauseMillis), |
342 | 110 |
4710 | 111 _gcs_are_young(true), |
342 | 112 |
113 _during_marking(false), | |
114 _in_marking_window(false), | |
115 _in_marking_window_im(false), | |
116 | |
4710 | 117 _recent_prev_end_times_for_all_gcs_sec( |
118 new TruncatedSeq(NumPrevPausesForHeuristics)), | |
342 | 119 |
120 _recent_avg_pause_time_ratio(0.0), | |
121 | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
122 _initiate_conc_mark_if_possible(false), |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
123 _during_initial_mark_pause(false), |
4710 | 124 _last_young_gc(false), |
125 _last_gc_was_young(false), | |
342 | 126 |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
127 _eden_bytes_before_gc(0), |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
128 _survivor_bytes_before_gc(0), |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
129 _capacity_before_gc(0), |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
130 |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
131 _eden_cset_region_length(0), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
132 _survivor_cset_region_length(0), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
133 _old_cset_region_length(0), |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
134 |
342 | 135 _collection_set(NULL), |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
136 _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
|
137 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
138 // Incremental CSet attributes |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
139 _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
|
140 _inc_cset_head(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
141 _inc_cset_tail(NULL), |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
142 _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
|
143 _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
|
144 _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
|
145 _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
|
146 _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
|
147 _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
|
148 |
342 | 149 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away |
150 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
151 #endif // _MSC_VER | |
152 | |
153 _short_lived_surv_rate_group(new SurvRateGroup(this, "Short Lived", | |
154 G1YoungSurvRateNumRegionsSummary)), | |
155 _survivor_surv_rate_group(new SurvRateGroup(this, "Survivor", | |
545 | 156 G1YoungSurvRateNumRegionsSummary)), |
342 | 157 // add here any more surv rate groups |
545 | 158 _recorded_survivor_regions(0), |
159 _recorded_survivor_head(NULL), | |
160 _recorded_survivor_tail(NULL), | |
1356 | 161 _survivors_age_table(true), |
162 | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
163 _gc_overhead_perc(0.0) { |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
164 |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
165 // 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
|
166 // 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
|
167 // so it's done as soon as possible. |
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
168 HeapRegion::setup_heap_region_size(Arguments::min_heap_size()); |
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1111
diff
changeset
|
169 HeapRegionRemSet::setup_remset_size(); |
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
936
diff
changeset
|
170 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
171 G1ErgoVerbose::initialize(); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
172 if (PrintAdaptiveSizePolicy) { |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
173 // 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
|
174 G1ErgoVerbose::set_enabled(true); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
175 // 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
|
176 // 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
|
177 // changed in the future. |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
178 G1ErgoVerbose::set_level(ErgoHigh); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
179 } else { |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
180 G1ErgoVerbose::set_enabled(false); |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
181 } |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
182 |
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
183 // Verify PLAB sizes |
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3982
diff
changeset
|
184 const size_t region_size = HeapRegion::GrainWords; |
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
185 if (YoungPLABSize > region_size || OldPLABSize > region_size) { |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
186 char buffer[128]; |
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3982
diff
changeset
|
187 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
|
188 OldPLABSize > region_size ? "Old" : "Young", region_size); |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
189 vm_exit_during_initialization(buffer); |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
190 } |
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1388
diff
changeset
|
191 |
342 | 192 _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); |
193 _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; | |
194 | |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
195 _phase_times = new G1GCPhaseTimes(_parallel_gc_threads); |
342 | 196 |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
197 int index = MIN2(_parallel_gc_threads - 1, 7); |
342 | 198 |
199 _rs_length_diff_seq->add(rs_length_diff_defaults[index]); | |
200 _cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]); | |
4710 | 201 _young_cards_per_entry_ratio_seq->add( |
202 young_cards_per_entry_ratio_defaults[index]); | |
342 | 203 _cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]); |
204 _cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]); | |
205 _constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]); | |
206 _young_other_cost_per_region_ms_seq->add( | |
207 young_other_cost_per_region_ms_defaults[index]); | |
208 _non_young_other_cost_per_region_ms_seq->add( | |
209 non_young_other_cost_per_region_ms_defaults[index]); | |
210 | |
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
|
211 // 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
|
212 // 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
|
213 // 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
|
214 // 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
|
215 // 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
|
216 // 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
|
217 // 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
|
218 // 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
|
219 // 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
|
220 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
221 // 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
|
222 // 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
|
223 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
|
224 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
|
225 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
|
226 "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
|
227 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
228 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
229 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
|
230 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
|
231 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
|
232 "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
|
233 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
234 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
235 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
236 // 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
|
237 // 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
|
238 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
|
239 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
|
240 // 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
|
241 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
|
242 } 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
|
243 // 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
|
244 // 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
|
245 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
|
246 "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
|
247 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
248 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
249 |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
250 // 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
|
251 // 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
|
252 // 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
|
253 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
|
254 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
|
255 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
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
|
257 // 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
|
258 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
|
259 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
|
260 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
|
261 "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
|
262 "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
|
263 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
|
264 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
|
265 } |
79107c3a6bd5
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
1579
diff
changeset
|
266 |
751 | 267 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
|
268 double time_slice = (double) GCPauseIntervalMillis / 1000.0; |
342 | 269 _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time); |
8094
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
270 |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
271 uintx confidence_perc = G1ConfidencePercent; |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
272 // Put an artificial ceiling on this so that it's not set to a silly value. |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
273 if (confidence_perc > 100) { |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
274 confidence_perc = 100; |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
275 warning("G1ConfidencePercent is set to a value that is too large, " |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
276 "it's been updated to %u", confidence_perc); |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
277 } |
f1fb03a251e9
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
7449
diff
changeset
|
278 _sigma = (double) confidence_perc / 100.0; |
342 | 279 |
280 // start conservatively (around 50ms is about right) | |
281 _concurrent_mark_remark_times_ms->add(0.05); | |
282 _concurrent_mark_cleanup_times_ms->add(0.20); | |
283 _tenuring_threshold = MaxTenuringThreshold; | |
3868
ae73da50be4b
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
3867
diff
changeset
|
284 // _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
|
285 // update_young_list_target_length() during initialization. |
3868
ae73da50be4b
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
3867
diff
changeset
|
286 _max_survivor_regions = 0; |
545 | 287 |
1356 | 288 assert(GCTimeRatio > 0, |
289 "we should have set it to a default value set_g1_gc_flags() " | |
290 "if a user set it to 0"); | |
291 _gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio)); | |
292 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
293 uintx reserve_perc = G1ReservePercent; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
294 // 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
|
295 if (reserve_perc > 50) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
296 reserve_perc = 50; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
297 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
|
298 "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
|
299 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
300 _reserve_factor = (double) reserve_perc / 100.0; |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
301 // 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
|
302 // 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
|
303 _reserve_regions = 0; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
304 |
342 | 305 initialize_all(); |
4013 | 306 _collectionSetChooser = new CollectionSetChooser(); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
307 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags |
342 | 308 } |
309 | |
310 void G1CollectorPolicy::initialize_flags() { | |
311 set_min_alignment(HeapRegion::GrainBytes); | |
312 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
|
313 if (SurvivorRatio < 1) { |
1e458753107d
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
545
diff
changeset
|
314 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
|
315 } |
342 | 316 CollectorPolicy::initialize_flags(); |
317 } | |
318 | |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
319 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true) { |
7449 | 320 assert(G1NewSizePercent <= G1MaxNewSizePercent, "Min larger than max"); |
321 assert(G1NewSizePercent > 0 && G1NewSizePercent < 100, "Min out of bounds"); | |
322 assert(G1MaxNewSizePercent > 0 && G1MaxNewSizePercent < 100, "Max out of bounds"); | |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
323 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
324 if (FLAG_IS_CMDLINE(NewRatio)) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
325 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
|
326 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
|
327 } else { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
328 _sizer_kind = SizerNewRatio; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
329 _adaptive_size = false; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
330 return; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
331 } |
3976 | 332 } |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
333 |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
334 if (FLAG_IS_CMDLINE(NewSize)) { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
335 _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
336 1U); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
337 if (FLAG_IS_CMDLINE(MaxNewSize)) { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
338 _max_desired_young_length = |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
339 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
340 1U); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
341 _sizer_kind = SizerMaxAndNewSize; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
342 _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
|
343 } else { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
344 _sizer_kind = SizerNewSizeOnly; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
345 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
346 } else if (FLAG_IS_CMDLINE(MaxNewSize)) { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
347 _max_desired_young_length = |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
348 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
349 1U); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
350 _sizer_kind = SizerMaxNewSizeOnly; |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
351 } |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
352 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
353 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
354 uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) { |
7449 | 355 uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100; |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
356 return MAX2(1U, default_value); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
357 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
358 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
359 uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { |
7449 | 360 uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100; |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
361 return MAX2(1U, default_value); |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
362 } |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
363 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
364 void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
365 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
|
366 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
367 switch (_sizer_kind) { |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
368 case SizerDefaults: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
369 _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
|
370 _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
|
371 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
372 case SizerNewSizeOnly: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
373 _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
|
374 _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
|
375 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
376 case SizerMaxNewSizeOnly: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
377 _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
|
378 _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
|
379 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
380 case SizerMaxAndNewSize: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
381 // 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
|
382 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
383 case SizerNewRatio: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
384 _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
|
385 _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
|
386 break; |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
387 default: |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
388 ShouldNotReachHere(); |
1285
a1c410de27e4
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
1283
diff
changeset
|
389 } |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
390 |
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
391 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
|
392 } |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
393 |
342 | 394 void G1CollectorPolicy::init() { |
395 // Set aside an initial future to_space. | |
396 _g1 = G1CollectedHeap::heap(); | |
397 | |
398 assert(Heap_lock->owned_by_self(), "Locking discipline."); | |
399 | |
545 | 400 initialize_gc_policy_counters(); |
401 | |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
402 if (adaptive_young_list_length()) { |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
403 _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
|
404 } else { |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
405 _young_list_fixed_length = _young_gen_sizer->min_desired_young_length(); |
342 | 406 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
407 _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
|
408 update_young_list_target_length(); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
409 _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
|
410 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
411 // 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
|
412 // 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
|
413 start_incremental_cset_building(); |
342 | 414 } |
415 | |
545 | 416 // 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
|
417 void G1CollectorPolicy::initialize_gc_policy_counters() { |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
418 _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3); |
545 | 419 } |
420 | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
421 bool G1CollectorPolicy::predict_will_fit(uint young_length, |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
422 double base_time_ms, |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
423 uint base_free_regions, |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
424 double target_pause_time_ms) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
425 if (young_length >= base_free_regions) { |
342 | 426 // end condition 1: not enough space for the young regions |
427 return false; | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
428 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
429 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
430 double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1); |
342 | 431 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
|
432 (size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); |
342 | 433 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
|
434 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
|
435 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
|
436 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
|
437 // end condition 2: prediction is over the target pause time |
342 | 438 return false; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
439 } |
342 | 440 |
441 size_t free_bytes = | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
442 (base_free_regions - young_length) * HeapRegion::GrainBytes; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
443 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
|
444 // end condition 3: out-of-space (conservatively!) |
342 | 445 return false; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
446 } |
342 | 447 |
448 // success! | |
449 return true; | |
450 } | |
451 | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
452 void G1CollectorPolicy::record_new_heap_size(uint new_number_of_regions) { |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
453 // re-calculate the necessary reserve |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
454 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
|
455 // 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
|
456 // smaller than 1.0) we'll get 1. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
457 _reserve_regions = (uint) ceil(reserve_regions_d); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
458 |
4729
1cbe7978b021
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
4728
diff
changeset
|
459 _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
|
460 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
461 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
462 uint G1CollectorPolicy::calculate_young_list_desired_min_length( |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
463 uint base_min_length) { |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
464 uint desired_min_length = 0; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
465 if (adaptive_young_list_length()) { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
466 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
|
467 double now_sec = os::elapsedTime(); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
468 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
|
469 double alloc_rate_ms = predict_alloc_rate_ms(); |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
470 desired_min_length = (uint) ceil(alloc_rate_ms * when_ms); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
471 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
472 // 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
|
473 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
474 } |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
475 desired_min_length += base_min_length; |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
476 // 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
|
477 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
|
478 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
479 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
480 uint G1CollectorPolicy::calculate_young_list_desired_max_length() { |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
481 // 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
|
482 // 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
|
483 // 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
|
484 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
|
485 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
486 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
487 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
|
488 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
|
489 // 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
|
490 // otherwise, use the given value. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
491 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
|
492 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
493 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
494 // 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
|
495 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
496 // This is how many young regions we already have (currently: the survivors). |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
497 uint base_min_length = recorded_survivor_regions(); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
498 // 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
|
499 // can allocate one eden region in the worst-case. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
500 uint absolute_min_length = base_min_length + 1; |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
501 uint desired_min_length = |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
502 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
|
503 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
|
504 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
|
505 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
506 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
507 // 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
|
508 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
509 // We will try our best not to "eat" into the reserve. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
510 uint absolute_max_length = 0; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
511 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
|
512 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
|
513 } |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
514 uint desired_max_length = calculate_young_list_desired_max_length(); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
515 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
|
516 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
|
517 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
518 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
519 uint young_list_target_length = 0; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
520 if (adaptive_young_list_length()) { |
4710 | 521 if (gcs_are_young()) { |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
522 young_list_target_length = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
523 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
|
524 base_min_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
525 desired_min_length, |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
526 desired_max_length); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
527 _rs_lengths_prediction = rs_lengths; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
528 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
529 // 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
|
530 // 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
|
531 // 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
|
532 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
533 } else { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
534 // 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
|
535 // 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
|
536 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
|
537 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
538 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
539 // 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
|
540 // 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
|
541 // 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
|
542 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
|
543 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
|
544 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
545 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
|
546 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
|
547 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
548 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
549 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
|
550 "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
|
551 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
|
552 _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
|
553 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
554 update_max_gc_locker_expansion(); |
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 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
557 uint |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
558 G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths, |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
559 uint base_min_length, |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
560 uint desired_min_length, |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
561 uint desired_max_length) { |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
562 assert(adaptive_young_list_length(), "pre-condition"); |
4710 | 563 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
|
564 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
565 // 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
|
566 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
|
567 return desired_min_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
568 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
569 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
570 // 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
|
571 // 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
|
572 // 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
|
573 // 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
|
574 // survivor_regions_evac_time prediction. |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
575 assert(desired_min_length > base_min_length, "invariant"); |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
576 uint min_young_length = desired_min_length - base_min_length; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
577 assert(desired_max_length > base_min_length, "invariant"); |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
578 uint max_young_length = desired_max_length - base_min_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 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
|
581 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
|
582 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
|
583 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
|
584 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
|
585 double base_time_ms = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
586 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
|
587 survivor_regions_evac_time; |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
588 uint available_free_regions = _free_regions_at_end_of_collection; |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
589 uint base_free_regions = 0; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
590 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
|
591 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
|
592 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
593 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
594 // 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
|
595 // 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
|
596 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
597 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
|
598 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
|
599 // 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
|
600 // 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
|
601 // 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
|
602 // 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
|
603 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
|
604 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
|
605 // 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
|
606 // 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
|
607 // 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
|
608 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
|
609 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
610 // 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
|
611 // 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
|
612 // length. The loop invariants are: |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
613 // |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
614 // 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
|
615 // 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
|
616 // 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
|
617 // |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
618 // 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
|
619 // 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
|
620 // 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
|
621 // 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
|
622 // 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
|
623 // 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
|
624 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
625 assert(min_young_length < max_young_length, "invariant"); |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
626 uint diff = (max_young_length - min_young_length) / 2; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
627 while (diff > 0) { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
628 uint young_length = min_young_length + diff; |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
629 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
|
630 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
|
631 min_young_length = young_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
632 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
633 max_young_length = young_length; |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
634 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
635 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
|
636 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
|
637 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
638 // 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
|
639 // 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
|
640 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
641 // 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
|
642 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
|
643 "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
|
644 "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
|
645 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
|
646 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
|
647 "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
|
648 "fit into the pause target"); |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
649 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
|
650 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
|
651 "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
|
652 "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
|
653 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
654 } else { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
655 // 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
|
656 // 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
|
657 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
658 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
|
659 } |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
660 |
545 | 661 double G1CollectorPolicy::predict_survivor_regions_evac_time() { |
662 double survivor_regions_evac_time = 0.0; | |
663 for (HeapRegion * r = _recorded_survivor_head; | |
664 r != NULL && r != _recorded_survivor_tail->get_next_young_region(); | |
665 r = r->get_next_young_region()) { | |
6611 | 666 survivor_regions_evac_time += predict_region_elapsed_time_ms(r, gcs_are_young()); |
545 | 667 } |
668 return survivor_regions_evac_time; | |
669 } | |
670 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
671 void G1CollectorPolicy::revise_young_list_target_length_if_necessary() { |
342 | 672 guarantee( adaptive_young_list_length(), "should not call this otherwise" ); |
673 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
674 size_t rs_lengths = _g1->young_list()->sampled_rs_lengths(); |
342 | 675 if (rs_lengths > _rs_lengths_prediction) { |
676 // add 10% to avoid having to recalculate often | |
677 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
|
678 update_young_list_target_length(rs_lengths_prediction); |
342 | 679 } |
680 } | |
681 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
682 |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
683 |
342 | 684 HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size, |
685 bool is_tlab, | |
686 bool* gc_overhead_limit_was_exceeded) { | |
687 guarantee(false, "Not using this policy feature yet."); | |
688 return NULL; | |
689 } | |
690 | |
691 // This method controls how a collector handles one or more | |
692 // of its generations being fully allocated. | |
693 HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size, | |
694 bool is_tlab) { | |
695 guarantee(false, "Not using this policy feature yet."); | |
696 return NULL; | |
697 } | |
698 | |
699 | |
700 #ifndef PRODUCT | |
701 bool G1CollectorPolicy::verify_young_ages() { | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
702 HeapRegion* head = _g1->young_list()->first_region(); |
342 | 703 return |
704 verify_young_ages(head, _short_lived_surv_rate_group); | |
705 // also call verify_young_ages on any additional surv rate groups | |
706 } | |
707 | |
708 bool | |
709 G1CollectorPolicy::verify_young_ages(HeapRegion* head, | |
710 SurvRateGroup *surv_rate_group) { | |
711 guarantee( surv_rate_group != NULL, "pre-condition" ); | |
712 | |
713 const char* name = surv_rate_group->name(); | |
714 bool ret = true; | |
715 int prev_age = -1; | |
716 | |
717 for (HeapRegion* curr = head; | |
718 curr != NULL; | |
719 curr = curr->get_next_young_region()) { | |
720 SurvRateGroup* group = curr->surv_rate_group(); | |
721 if (group == NULL && !curr->is_survivor()) { | |
722 gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); | |
723 ret = false; | |
724 } | |
725 | |
726 if (surv_rate_group == group) { | |
727 int age = curr->age_in_surv_rate_group(); | |
728 | |
729 if (age < 0) { | |
730 gclog_or_tty->print_cr("## %s: encountered negative age", name); | |
731 ret = false; | |
732 } | |
733 | |
734 if (age <= prev_age) { | |
735 gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " | |
736 "(%d, %d)", name, age, prev_age); | |
737 ret = false; | |
738 } | |
739 prev_age = age; | |
740 } | |
741 } | |
742 | |
743 return ret; | |
744 } | |
745 #endif // PRODUCT | |
746 | |
747 void G1CollectorPolicy::record_full_collection_start() { | |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
748 _full_collection_start_sec = os::elapsedTime(); |
342 | 749 // Release the future to-space so that it is available for compaction into. |
750 _g1->set_full_collection(); | |
751 } | |
752 | |
753 void G1CollectorPolicy::record_full_collection_end() { | |
754 // Consider this like a collection pause for the purposes of allocation | |
755 // since last pause. | |
756 double end_sec = os::elapsedTime(); | |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
757 double full_gc_time_sec = end_sec - _full_collection_start_sec; |
342 | 758 double full_gc_time_ms = full_gc_time_sec * 1000.0; |
759 | |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
760 _trace_gen1_time_data.record_full_collection(full_gc_time_ms); |
342 | 761 |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
762 update_recent_gc_times(end_sec, full_gc_time_ms); |
342 | 763 |
764 _g1->clear_full_collection(); | |
765 | |
4710 | 766 // "Nuke" the heuristics that control the young/mixed GC |
767 // transitions and make sure we start with young GCs after the Full GC. | |
768 set_gcs_are_young(true); | |
769 _last_young_gc = false; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
770 clear_initiate_conc_mark_if_possible(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
771 clear_during_initial_mark_pause(); |
342 | 772 _in_marking_window = false; |
773 _in_marking_window_im = false; | |
774 | |
775 _short_lived_surv_rate_group->start_adding_regions(); | |
776 // also call this on any additional surv rate groups | |
777 | |
545 | 778 record_survivor_regions(0, NULL, NULL); |
779 | |
342 | 780 _free_regions_at_end_of_collection = _g1->free_regions(); |
545 | 781 // Reset survivors SurvRateGroup. |
782 _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
|
783 update_young_list_target_length(); |
6011 | 784 _collectionSetChooser->clear(); |
1973 | 785 } |
342 | 786 |
787 void G1CollectorPolicy::record_stop_world_start() { | |
788 _stop_world_start = os::elapsedTime(); | |
789 } | |
790 | |
791 void G1CollectorPolicy::record_collection_pause_start(double start_time_sec, | |
792 size_t start_used) { | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4834
diff
changeset
|
793 // 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
|
794 // 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
|
795 // 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
|
796 update_survivors_policy(); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
797 |
1973 | 798 assert(_g1->used() == _g1->recalculate_used(), |
799 err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, | |
800 _g1->used(), _g1->recalculate_used())); | |
342 | 801 |
802 double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; | |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
803 _trace_gen0_time_data.record_start_collection(s_w_t_ms); |
342 | 804 _stop_world_start = 0.0; |
805 | |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
806 phase_times()->record_cur_collection_start_sec(start_time_sec); |
342 | 807 _cur_collection_pause_used_at_start_bytes = start_used; |
808 _cur_collection_pause_used_regions_at_start = _g1->used_regions(); | |
809 _pending_cards = _g1->pending_card_num(); | |
810 | |
6611 | 811 _collection_set_bytes_used_before = 0; |
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
812 _bytes_copied_during_gc = 0; |
342 | 813 |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
814 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
|
815 _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
|
816 _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
|
817 _capacity_before_gc = _g1->capacity(); |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
818 |
4710 | 819 _last_gc_was_young = false; |
342 | 820 |
821 // do that for any other surv rate groups | |
822 _short_lived_surv_rate_group->stop_adding_regions(); | |
1282 | 823 _survivors_age_table.clear(); |
545 | 824 |
342 | 825 assert( verify_young_ages(), "region age verification" ); |
826 } | |
827 | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
828 void G1CollectorPolicy::record_concurrent_mark_init_end(double |
342 | 829 mark_init_elapsed_time_ms) { |
830 _during_marking = true; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
831 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
|
832 clear_during_initial_mark_pause(); |
342 | 833 _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; |
834 } | |
835 | |
836 void G1CollectorPolicy::record_concurrent_mark_remark_start() { | |
837 _mark_remark_start_sec = os::elapsedTime(); | |
838 _during_marking = false; | |
839 } | |
840 | |
841 void G1CollectorPolicy::record_concurrent_mark_remark_end() { | |
842 double end_time_sec = os::elapsedTime(); | |
843 double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; | |
844 _concurrent_mark_remark_times_ms->add(elapsed_time_ms); | |
845 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
846 _prev_collection_pause_end_ms += elapsed_time_ms; | |
847 | |
848 _mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true); | |
849 } | |
850 | |
851 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { | |
852 _mark_cleanup_start_sec = os::elapsedTime(); | |
853 } | |
854 | |
4013 | 855 void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { |
4710 | 856 _last_young_gc = true; |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
857 _in_marking_window = false; |
342 | 858 } |
859 | |
860 void G1CollectorPolicy::record_concurrent_pause() { | |
861 if (_stop_world_start > 0.0) { | |
862 double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0; | |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
863 _trace_gen0_time_data.record_yield_time(yield_ms); |
342 | 864 } |
865 } | |
866 | |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
867 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
|
868 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
|
869 return false; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
870 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
871 |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
872 size_t marking_initiating_used_threshold = |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
873 (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
874 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
|
875 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
|
876 |
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
877 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
|
878 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
|
879 ergo_verbose5(ErgoConcCycles, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
880 "request concurrent cycle initiation", |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
881 ergo_format_reason("occupancy higher than threshold") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
882 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
|
883 ergo_format_byte("allocation request") |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
884 ergo_format_byte_perc("threshold") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
885 ergo_format_str("source"), |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
886 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
|
887 alloc_byte_size, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
888 marking_initiating_used_threshold, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
889 (double) InitiatingHeapOccupancyPercent, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
890 source); |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
891 return true; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
892 } else { |
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4829
diff
changeset
|
893 ergo_verbose5(ErgoConcCycles, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
894 "do not request concurrent cycle initiation", |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
895 ergo_format_reason("still doing mixed collections") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
896 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
|
897 ergo_format_byte("allocation request") |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
898 ergo_format_byte_perc("threshold") |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
899 ergo_format_str("source"), |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
900 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
|
901 alloc_byte_size, |
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
902 marking_initiating_used_threshold, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
903 (double) InitiatingHeapOccupancyPercent, |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
904 source); |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
905 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
906 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
907 |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
908 return false; |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
909 } |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
910 |
342 | 911 // Anything below that is considered to be zero |
912 #define MIN_TIMER_GRANULARITY 0.0000001 | |
913 | |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
914 void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms) { |
342 | 915 double end_time_sec = os::elapsedTime(); |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
916 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
|
917 "otherwise, the subtraction below does not make sense"); |
342 | 918 size_t rs_size = |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
919 _cur_collection_pause_used_regions_at_start - cset_region_length(); |
342 | 920 size_t cur_used_bytes = _g1->used(); |
921 assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); | |
922 bool last_pause_included_initial_mark = false; | |
1707 | 923 bool update_stats = !_g1->evacuation_failed(); |
342 | 924 |
925 #ifndef PRODUCT | |
926 if (G1YoungSurvRateVerbose) { | |
927 gclog_or_tty->print_cr(""); | |
928 _short_lived_surv_rate_group->print(); | |
929 // do that for any other surv rate groups too | |
930 } | |
931 #endif // PRODUCT | |
932 | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
933 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
|
934 if (last_pause_included_initial_mark) { |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
935 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
|
936 } 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
|
937 // 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
|
938 // 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
|
939 // 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
|
940 set_initiate_conc_mark_if_possible(); |
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
941 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
942 |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
943 _mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0, |
342 | 944 end_time_sec, false); |
945 | |
946 size_t freed_bytes = | |
947 _cur_collection_pause_used_at_start_bytes - cur_used_bytes; | |
948 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
|
949 |
342 | 950 double survival_fraction = |
951 (double)surviving_bytes/ | |
952 (double)_collection_set_bytes_used_before; | |
953 | |
595
3698e8f47799
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
547
diff
changeset
|
954 if (update_stats) { |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
955 _trace_gen0_time_data.record_end_collection(pause_time_ms, phase_times()); |
342 | 956 // this is where we update the allocation rate of the application |
957 double app_time_ms = | |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
958 (phase_times()->cur_collection_start_sec() * 1000.0 - _prev_collection_pause_end_ms); |
342 | 959 if (app_time_ms < MIN_TIMER_GRANULARITY) { |
960 // This usually happens due to the timer not having the required | |
961 // granularity. Some Linuxes are the usual culprits. | |
962 // We'll just set it to something (arbitrarily) small. | |
963 app_time_ms = 1.0; | |
964 } | |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
965 // 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
|
966 // 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
|
967 // 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
|
968 // 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
|
969 // 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
|
970 // 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
|
971 // 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
|
972 // place we can safely ignore them here. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
973 uint regions_allocated = eden_cset_region_length(); |
342 | 974 double alloc_rate_ms = (double) regions_allocated / app_time_ms; |
975 _alloc_rate_ms_seq->add(alloc_rate_ms); | |
976 | |
977 double interval_ms = | |
978 (end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; | |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
979 update_recent_gc_times(end_time_sec, pause_time_ms); |
342 | 980 _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
|
981 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
|
982 (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
|
983 #ifndef PRODUCT |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
984 // 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
|
985 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
|
986 gclog_or_tty->print_cr("-------------------------------------------"); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
987 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
|
988 _recent_gc_times_ms->dump(); |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
989 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
|
990 _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
|
991 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
|
992 _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
|
993 // 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
|
994 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
|
995 #endif // !PRODUCT |
23b9a8d315fc
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
1086
diff
changeset
|
996 // 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
|
997 // 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
|
998 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
|
999 _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
|
1000 } else { |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1001 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
|
1002 _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
|
1003 } |
89f1b9ae8991
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
1043
diff
changeset
|
1004 } |
342 | 1005 } |
1006 bool new_in_marking_window = _in_marking_window; | |
1007 bool new_in_marking_window_im = false; | |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1008 if (during_initial_mark_pause()) { |
342 | 1009 new_in_marking_window = true; |
1010 new_in_marking_window_im = true; | |
1011 } | |
1012 | |
4710 | 1013 if (_last_young_gc) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1014 // 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
|
1015 // 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
|
1016 |
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
|
1017 if (!last_pause_included_initial_mark) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1018 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
|
1019 "do not start mixed GCs")) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1020 set_gcs_are_young(false); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1021 } |
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
|
1022 } else { |
4710 | 1023 ergo_verbose0(ErgoMixedGCs, |
1024 "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
|
1025 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
|
1026 } |
4710 | 1027 _last_young_gc = false; |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1028 } |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1029 |
4710 | 1030 if (!_last_gc_was_young) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1031 // 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
|
1032 // mixed GCs or not. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1033 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1034 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
|
1035 "do not continue mixed GCs")) { |
4710 | 1036 set_gcs_are_young(true); |
342 | 1037 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1038 } |
4710 | 1039 |
342 | 1040 _short_lived_surv_rate_group->start_adding_regions(); |
1041 // do that for any other surv rate groupsx | |
1042 | |
677 | 1043 if (update_stats) { |
342 | 1044 double cost_per_card_ms = 0.0; |
1045 if (_pending_cards > 0) { | |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1046 cost_per_card_ms = phase_times()->average_last_update_rs_time() / (double) _pending_cards; |
342 | 1047 _cost_per_card_ms_seq->add(cost_per_card_ms); |
1048 } | |
1049 | |
1050 size_t cards_scanned = _g1->cards_scanned(); | |
1051 | |
1052 double cost_per_entry_ms = 0.0; | |
1053 if (cards_scanned > 10) { | |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1054 cost_per_entry_ms = phase_times()->average_last_scan_rs_time() / (double) cards_scanned; |
4710 | 1055 if (_last_gc_was_young) { |
342 | 1056 _cost_per_entry_ms_seq->add(cost_per_entry_ms); |
4710 | 1057 } else { |
1058 _mixed_cost_per_entry_ms_seq->add(cost_per_entry_ms); | |
1059 } | |
342 | 1060 } |
1061 | |
1062 if (_max_rs_lengths > 0) { | |
1063 double cards_per_entry_ratio = | |
1064 (double) cards_scanned / (double) _max_rs_lengths; | |
4710 | 1065 if (_last_gc_was_young) { |
1066 _young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
1067 } else { | |
1068 _mixed_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); | |
1069 } | |
342 | 1070 } |
1071 | |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1072 // 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
|
1073 // 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
|
1074 // 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
|
1075 // 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
|
1076 // _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
|
1077 // 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
|
1078 // 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
|
1079 // _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
|
1080 // 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
|
1081 // 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
|
1082 // 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
|
1083 // 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
|
1084 // conditional below just in case. |
4130
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1085 size_t rs_length_diff = 0; |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1086 if (_max_rs_lengths > _recorded_rs_lengths) { |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1087 rs_length_diff = _max_rs_lengths - _recorded_rs_lengths; |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1088 } |
d23d2b18183e
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
4097
diff
changeset
|
1089 _rs_length_diff_seq->add((double) rs_length_diff); |
342 | 1090 |
1091 size_t copied_bytes = surviving_bytes; | |
1092 double cost_per_byte_ms = 0.0; | |
1093 if (copied_bytes > 0) { | |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1094 cost_per_byte_ms = phase_times()->average_last_obj_copy_time() / (double) copied_bytes; |
4710 | 1095 if (_in_marking_window) { |
342 | 1096 _cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); |
4710 | 1097 } else { |
342 | 1098 _cost_per_byte_ms_seq->add(cost_per_byte_ms); |
4710 | 1099 } |
342 | 1100 } |
1101 | |
1102 double all_other_time_ms = pause_time_ms - | |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1103 (phase_times()->average_last_update_rs_time() + phase_times()->average_last_scan_rs_time() |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1104 + phase_times()->average_last_obj_copy_time() + phase_times()->average_last_termination_time()); |
342 | 1105 |
1106 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
|
1107 if (young_cset_region_length() > 0) { |
342 | 1108 young_other_time_ms = |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1109 phase_times()->young_cset_choice_time_ms() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1110 phase_times()->young_free_cset_time_ms(); |
342 | 1111 _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
|
1112 (double) young_cset_region_length()); |
342 | 1113 } |
1114 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
|
1115 if (old_cset_region_length() > 0) { |
342 | 1116 non_young_other_time_ms = |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1117 phase_times()->non_young_cset_choice_time_ms() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1118 phase_times()->non_young_free_cset_time_ms(); |
342 | 1119 |
1120 _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
|
1121 (double) old_cset_region_length()); |
342 | 1122 } |
1123 | |
1124 double constant_other_time_ms = all_other_time_ms - | |
1125 (young_other_time_ms + non_young_other_time_ms); | |
1126 _constant_other_time_ms_seq->add(constant_other_time_ms); | |
1127 | |
1128 double survival_ratio = 0.0; | |
6611 | 1129 if (_collection_set_bytes_used_before > 0) { |
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3823
diff
changeset
|
1130 survival_ratio = (double) _bytes_copied_during_gc / |
6611 | 1131 (double) _collection_set_bytes_used_before; |
342 | 1132 } |
1133 | |
1134 _pending_cards_seq->add((double) _pending_cards); | |
1135 _rs_lengths_seq->add((double) _max_rs_lengths); | |
1136 } | |
1137 | |
1138 _in_marking_window = new_in_marking_window; | |
1139 _in_marking_window_im = new_in_marking_window_im; | |
1140 _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
|
1141 update_young_list_target_length(); |
342 | 1142 |
1111 | 1143 // Note that _mmu_tracker->max_gc_time() returns the time in seconds. |
1282 | 1144 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1145 adjust_concurrent_refinement(phase_times()->average_last_update_rs_time(), |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1146 phase_times()->sum_last_update_rs_processed_buffers(), update_rs_time_goal_ms); |
4013 | 1147 |
6011 | 1148 _collectionSetChooser->verify(); |
342 | 1149 } |
1150 | |
6059 | 1151 #define EXT_SIZE_FORMAT "%.1f%s" |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1152 #define EXT_SIZE_PARAMS(bytes) \ |
6059 | 1153 byte_size_in_proper_unit((double)(bytes)), \ |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1154 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
|
1155 |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1156 void G1CollectorPolicy::print_heap_transition() { |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1157 _g1->print_size_transition(gclog_or_tty, |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1158 _cur_collection_pause_used_at_start_bytes, _g1->used(), _g1->capacity()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1159 } |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1160 |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1161 void G1CollectorPolicy::print_detailed_heap_transition() { |
3764
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1162 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
|
1163 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
|
1164 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
|
1165 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
|
1166 size_t used = _g1->used(); |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1167 size_t capacity = _g1->capacity(); |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1168 size_t eden_capacity = |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1169 (_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
|
1170 |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1171 gclog_or_tty->print_cr( |
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1172 " [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
|
1173 "Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1174 "Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1175 EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1176 EXT_SIZE_PARAMS(_eden_bytes_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1177 EXT_SIZE_PARAMS(_prev_eden_capacity), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1178 EXT_SIZE_PARAMS(eden_bytes), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1179 EXT_SIZE_PARAMS(eden_capacity), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1180 EXT_SIZE_PARAMS(_survivor_bytes_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1181 EXT_SIZE_PARAMS(survivor_bytes), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1182 EXT_SIZE_PARAMS(used_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1183 EXT_SIZE_PARAMS(_capacity_before_gc), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1184 EXT_SIZE_PARAMS(used), |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1185 EXT_SIZE_PARAMS(capacity)); |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1186 |
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1187 _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
|
1188 } |
053d84a76d3d
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
2430
diff
changeset
|
1189 |
1111 | 1190 void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time, |
1191 double update_rs_processed_buffers, | |
1192 double goal_ms) { | |
1193 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
1194 ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine(); | |
1195 | |
1282 | 1196 if (G1UseAdaptiveConcRefinement) { |
1111 | 1197 const int k_gy = 3, k_gr = 6; |
1198 const double inc_k = 1.1, dec_k = 0.9; | |
1199 | |
1200 int g = cg1r->green_zone(); | |
1201 if (update_rs_time > goal_ms) { | |
1202 g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing. | |
1203 } else { | |
1204 if (update_rs_time < goal_ms && update_rs_processed_buffers > g) { | |
1205 g = (int)MAX2(g * inc_k, g + 1.0); | |
1206 } | |
1207 } | |
1208 // Change the refinement threads params | |
1209 cg1r->set_green_zone(g); | |
1210 cg1r->set_yellow_zone(g * k_gy); | |
1211 cg1r->set_red_zone(g * k_gr); | |
1212 cg1r->reinitialize_threads(); | |
1213 | |
1214 int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1); | |
1215 int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta, | |
1216 cg1r->yellow_zone()); | |
1217 // Change the barrier params | |
1218 dcqs.set_process_completed_threshold(processing_threshold); | |
1219 dcqs.set_max_completed_queue(cg1r->red_zone()); | |
1220 } | |
1221 | |
1222 int curr_queue_size = dcqs.completed_buffers_num(); | |
1223 if (curr_queue_size >= cg1r->yellow_zone()) { | |
1224 dcqs.set_completed_queue_padding(curr_queue_size); | |
1225 } else { | |
1226 dcqs.set_completed_queue_padding(0); | |
1227 } | |
1228 dcqs.notify_if_necessary(); | |
1229 } | |
1230 | |
342 | 1231 double |
1232 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, | |
1233 size_t scanned_cards) { | |
1234 return | |
1235 predict_rs_update_time_ms(pending_cards) + | |
1236 predict_rs_scan_time_ms(scanned_cards) + | |
1237 predict_constant_other_time_ms(); | |
1238 } | |
1239 | |
1240 double | |
6611 | 1241 G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { |
1242 size_t rs_length = predict_rs_length_diff(); | |
342 | 1243 size_t card_num; |
4710 | 1244 if (gcs_are_young()) { |
342 | 1245 card_num = predict_young_card_num(rs_length); |
4710 | 1246 } else { |
342 | 1247 card_num = predict_non_young_card_num(rs_length); |
4710 | 1248 } |
6611 | 1249 return predict_base_elapsed_time_ms(pending_cards, card_num); |
342 | 1250 } |
1251 | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1252 size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { |
342 | 1253 size_t bytes_to_copy; |
1254 if (hr->is_marked()) | |
1255 bytes_to_copy = hr->max_live_bytes(); | |
1256 else { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1257 assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant"); |
342 | 1258 int age = hr->age_in_surv_rate_group(); |
545 | 1259 double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); |
342 | 1260 bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate); |
1261 } | |
1262 return bytes_to_copy; | |
1263 } | |
1264 | |
6611 | 1265 double |
1266 G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, | |
1267 bool for_young_gc) { | |
1268 size_t rs_length = hr->rem_set()->occupied(); | |
1269 size_t card_num; | |
1270 | |
1271 // Predicting the number of cards is based on which type of GC | |
1272 // we're predicting for. | |
1273 if (for_young_gc) { | |
1274 card_num = predict_young_card_num(rs_length); | |
1275 } else { | |
1276 card_num = predict_non_young_card_num(rs_length); | |
1277 } | |
1278 size_t bytes_to_copy = predict_bytes_to_copy(hr); | |
1279 | |
1280 double region_elapsed_time_ms = | |
1281 predict_rs_scan_time_ms(card_num) + | |
1282 predict_object_copy_time_ms(bytes_to_copy); | |
1283 | |
1284 // The prediction of the "other" time for this region is based | |
1285 // upon the region type and NOT the GC type. | |
1286 if (hr->is_young()) { | |
1287 region_elapsed_time_ms += predict_young_other_time_ms(1); | |
1288 } else { | |
1289 region_elapsed_time_ms += predict_non_young_other_time_ms(1); | |
1290 } | |
1291 return region_elapsed_time_ms; | |
1292 } | |
1293 | |
342 | 1294 void |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1295 G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length, |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1296 uint survivor_cset_region_length) { |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1297 _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
|
1298 _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
|
1299 _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
|
1300 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1301 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1302 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
|
1303 _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
|
1304 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1305 |
342 | 1306 void G1CollectorPolicy::update_recent_gc_times(double end_time_sec, |
1307 double elapsed_ms) { | |
1308 _recent_gc_times_ms->add(elapsed_ms); | |
1309 _recent_prev_end_times_for_all_gcs_sec->add(end_time_sec); | |
1310 _prev_collection_pause_end_ms = end_time_sec * 1000.0; | |
1311 } | |
1312 | |
1313 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
|
1314 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
|
1315 double threshold = _gc_overhead_perc; |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1316 if (recent_gc_overhead > threshold) { |
751 | 1317 // We will double the existing space, or take |
1318 // G1ExpandByPercentOfAvailable % of the available expansion | |
1319 // space, whichever is smaller, bounded below by a minimum | |
1320 // expansion (unless that's all that's left.) | |
342 | 1321 const size_t min_expand_bytes = 1*M; |
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2152
diff
changeset
|
1322 size_t reserved_bytes = _g1->max_capacity(); |
342 | 1323 size_t committed_bytes = _g1->capacity(); |
1324 size_t uncommitted_bytes = reserved_bytes - committed_bytes; | |
1325 size_t expand_bytes; | |
1326 size_t expand_bytes_via_pct = | |
751 | 1327 uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; |
342 | 1328 expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); |
1329 expand_bytes = MAX2(expand_bytes, min_expand_bytes); | |
1330 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
|
1331 |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1332 ergo_verbose5(ErgoHeapSizing, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1333 "attempt heap expansion", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1334 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
|
1335 "threshold after GC") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1336 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
|
1337 ergo_format_perc("threshold") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1338 ergo_format_byte("uncommitted") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1339 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
|
1340 recent_gc_overhead, threshold, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1341 uncommitted_bytes, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1342 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
|
1343 |
342 | 1344 return expand_bytes; |
1345 } else { | |
1346 return 0; | |
1347 } | |
1348 } | |
1349 | |
1350 void G1CollectorPolicy::print_tracing_info() const { | |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
1351 _trace_gen0_time_data.print(); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
1352 _trace_gen1_time_data.print(); |
342 | 1353 } |
1354 | |
1355 void G1CollectorPolicy::print_yg_surv_rate_info() const { | |
1356 #ifndef PRODUCT | |
1357 _short_lived_surv_rate_group->print_surv_rate_summary(); | |
1358 // add this call for any other surv rate groups | |
1359 #endif // PRODUCT | |
1360 } | |
1361 | |
1362 #ifndef PRODUCT | |
1363 // for debugging, bit of a hack... | |
1364 static char* | |
1365 region_num_to_mbs(int length) { | |
1366 static char buffer[64]; | |
1367 double bytes = (double) (length * HeapRegion::GrainBytes); | |
1368 double mbs = bytes / (double) (1024 * 1024); | |
1369 sprintf(buffer, "%7.2lfMB", mbs); | |
1370 return buffer; | |
1371 } | |
1372 #endif // PRODUCT | |
1373 | |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1374 uint G1CollectorPolicy::max_regions(int purpose) { |
342 | 1375 switch (purpose) { |
1376 case GCAllocForSurvived: | |
545 | 1377 return _max_survivor_regions; |
342 | 1378 case GCAllocForTenured: |
545 | 1379 return REGIONS_UNLIMITED; |
342 | 1380 default: |
545 | 1381 ShouldNotReachHere(); |
1382 return REGIONS_UNLIMITED; | |
342 | 1383 }; |
1384 } | |
1385 | |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1386 void G1CollectorPolicy::update_max_gc_locker_expansion() { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1387 uint expansion_region_num = 0; |
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1388 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
|
1389 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
|
1390 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
|
1391 // 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
|
1392 // less than 1.0) we'll get 1. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1393 expansion_region_num = (uint) ceil(expansion_region_num_d); |
1991
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1394 } else { |
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1395 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
|
1396 } |
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1397 _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
|
1398 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
|
1399 } |
016a3628c885
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
1973
diff
changeset
|
1400 |
545 | 1401 // Calculates survivor space parameters. |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1402 void G1CollectorPolicy::update_survivors_policy() { |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1403 double max_survivor_regions_d = |
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1404 (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
|
1405 // 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
|
1406 // smaller than 1.0) we'll get 1. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1407 _max_survivor_regions = (uint) ceil(max_survivor_regions_d); |
3919
4f41766176cf
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
3914
diff
changeset
|
1408 |
3868
ae73da50be4b
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
3867
diff
changeset
|
1409 _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( |
545 | 1410 HeapRegion::GrainWords * _max_survivor_regions); |
1411 } | |
1412 | |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1413 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
|
1414 GCCause::Cause gc_cause) { |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1415 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1416 if (!during_cycle) { |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1417 ergo_verbose1(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1418 "request concurrent cycle initiation", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1419 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
|
1420 ergo_format_str("GC cause"), |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1421 GCCause::to_string(gc_cause)); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1422 set_initiate_conc_mark_if_possible(); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1423 return true; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1424 } else { |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1425 ergo_verbose1(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1426 "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
|
1427 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
|
1428 ergo_format_str("GC cause"), |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1429 GCCause::to_string(gc_cause)); |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1430 return false; |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1431 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1432 } |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1433 |
342 | 1434 void |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1435 G1CollectorPolicy::decide_on_conc_mark_initiation() { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1436 // 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
|
1437 // initial-mark pause. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1438 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1439 // 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
|
1440 // 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
|
1441 // 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
|
1442 // initial-mark pause). |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1443 assert(!during_initial_mark_pause(), "pre-condition"); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1444 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1445 if (initiate_conc_mark_if_possible()) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1446 // 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
|
1447 // 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
|
1448 // concurrent marking cycle. So we might initiate one. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1449 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1450 bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1451 if (!during_cycle) { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1452 // 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
|
1453 // 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
|
1454 // initiate a new cycle. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1455 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1456 set_during_initial_mark_pause(); |
4710 | 1457 // We do not allow mixed GCs during marking. |
1458 if (!gcs_are_young()) { | |
1459 set_gcs_are_young(true); | |
1460 ergo_verbose0(ErgoMixedGCs, | |
1461 "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
|
1462 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
|
1463 } |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1464 |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1465 // 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
|
1466 // we've already acted on it. |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1467 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
|
1468 |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1469 ergo_verbose0(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1470 "initiate concurrent cycle", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1471 ergo_format_reason("concurrent cycle initiation requested")); |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1472 } else { |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1473 // The concurrent marking thread is still finishing up the |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1474 // 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
|
1475 // overlap. In particular, the concurrent marking thread might |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1476 // 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
|
1477 // 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
|
1478 // 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
|
1479 // 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
|
1480 // 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
|
1481 // periodically yields while clearing the next marking bitmap |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1482 // 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
|
1483 // 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
|
1484 // 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
|
1485 ergo_verbose0(ErgoConcCycles, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1486 "do not initiate concurrent cycle", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1487 ergo_format_reason("concurrent cycle already in progress")); |
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1488 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1489 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1490 } |
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1356
diff
changeset
|
1491 |
342 | 1492 class KnownGarbageClosure: public HeapRegionClosure { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1493 G1CollectedHeap* _g1h; |
342 | 1494 CollectionSetChooser* _hrSorted; |
1495 | |
1496 public: | |
1497 KnownGarbageClosure(CollectionSetChooser* hrSorted) : | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1498 _g1h(G1CollectedHeap::heap()), _hrSorted(hrSorted) { } |
342 | 1499 |
1500 bool doHeapRegion(HeapRegion* r) { | |
1501 // We only include humongous regions in collection | |
1502 // sets when concurrent mark shows that their contained object is | |
1503 // unreachable. | |
1504 | |
1505 // Do we have any marking information for this region? | |
1506 if (r->is_marked()) { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1507 // 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
|
1508 // 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
|
1509 // before we fill them up). |
6011 | 1510 if (_hrSorted->should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { |
1511 _hrSorted->add_region(r); | |
342 | 1512 } |
1513 } | |
1514 return false; | |
1515 } | |
1516 }; | |
1517 | |
1518 class ParKnownGarbageHRClosure: public HeapRegionClosure { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1519 G1CollectedHeap* _g1h; |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6219
diff
changeset
|
1520 CSetChooserParUpdater _cset_updater; |
342 | 1521 |
1522 public: | |
1523 ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, | |
6011 | 1524 uint chunk_size) : |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6219
diff
changeset
|
1525 _g1h(G1CollectedHeap::heap()), |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6219
diff
changeset
|
1526 _cset_updater(hrSorted, true /* parallel */, chunk_size) { } |
342 | 1527 |
1528 bool doHeapRegion(HeapRegion* r) { | |
1529 // Do we have any marking information for this region? | |
1530 if (r->is_marked()) { | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1531 // 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
|
1532 // 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
|
1533 // before we fill them up). |
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6219
diff
changeset
|
1534 if (_cset_updater.should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { |
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6219
diff
changeset
|
1535 _cset_updater.add_region(r); |
342 | 1536 } |
1537 } | |
1538 return false; | |
1539 } | |
1540 }; | |
1541 | |
1542 class ParKnownGarbageTask: public AbstractGangTask { | |
1543 CollectionSetChooser* _hrSorted; | |
6011 | 1544 uint _chunk_size; |
342 | 1545 G1CollectedHeap* _g1; |
1546 public: | |
6011 | 1547 ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size) : |
342 | 1548 AbstractGangTask("ParKnownGarbageTask"), |
1549 _hrSorted(hrSorted), _chunk_size(chunk_size), | |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1550 _g1(G1CollectedHeap::heap()) { } |
342 | 1551 |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4727
diff
changeset
|
1552 void work(uint worker_id) { |
6011 | 1553 ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size); |
1554 | |
342 | 1555 // 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
|
1556 _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
|
1557 _g1->workers()->active_workers(), |
355 | 1558 HeapRegion::InitialClaimValue); |
342 | 1559 } |
1560 }; | |
1561 | |
1562 void | |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1563 G1CollectorPolicy::record_concurrent_mark_cleanup_end(int no_of_gc_threads) { |
6011 | 1564 _collectionSetChooser->clear(); |
4013 | 1565 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1566 uint region_num = _g1->n_regions(); |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1779
diff
changeset
|
1567 if (G1CollectedHeap::use_parallel_gc_threads()) { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1568 const uint OverpartitionFactor = 4; |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1569 uint WorkUnit; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1570 // The use of MinChunkSize = 8 in the original code |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1571 // causes some assertion failures when the total number of |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1572 // 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
|
1573 // Should the original code also be fixed? |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1574 if (no_of_gc_threads > 0) { |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1575 const uint MinWorkUnit = MAX2(region_num / no_of_gc_threads, 1U); |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1576 WorkUnit = MAX2(region_num / (no_of_gc_threads * OverpartitionFactor), |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1577 MinWorkUnit); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1578 } else { |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1579 assert(no_of_gc_threads > 0, |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1580 "The active gc workers should be greater than 0"); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1581 // In a product build do something reasonable to avoid a crash. |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1582 const uint MinWorkUnit = MAX2(region_num / (uint) ParallelGCThreads, 1U); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1583 WorkUnit = |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1584 MAX2(region_num / (uint) (ParallelGCThreads * OverpartitionFactor), |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1585 MinWorkUnit); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1586 } |
6011 | 1587 _collectionSetChooser->prepare_for_par_region_addition(_g1->n_regions(), |
1588 WorkUnit); | |
342 | 1589 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
|
1590 (int) WorkUnit); |
342 | 1591 _g1->workers()->run_task(&parKnownGarbageTask); |
355 | 1592 |
1593 assert(_g1->check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
1594 "sanity check"); | |
342 | 1595 } else { |
1596 KnownGarbageClosure knownGarbagecl(_collectionSetChooser); | |
1597 _g1->heap_region_iterate(&knownGarbagecl); | |
1598 } | |
4013 | 1599 |
6011 | 1600 _collectionSetChooser->sort_regions(); |
1601 | |
4013 | 1602 double end_sec = os::elapsedTime(); |
1603 double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0; | |
1604 _concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); | |
1605 _cur_mark_stop_world_time_ms += elapsed_time_ms; | |
1606 _prev_collection_pause_end_ms += elapsed_time_ms; | |
1607 _mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec, true); | |
342 | 1608 } |
1609 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1610 // 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
|
1611 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
|
1612 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
|
1613 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
|
1614 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1615 assert(!hr->in_collection_set(), "should not already be in the CSet"); |
342 | 1616 hr->set_in_collection_set(true); |
1617 hr->set_next_in_collection_set(_collection_set); | |
1618 _collection_set = hr; | |
1619 _collection_set_bytes_used_before += hr->used(); | |
526 | 1620 _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
|
1621 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
|
1622 _recorded_rs_lengths += rs_length; |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1623 _old_cset_region_length += 1; |
342 | 1624 } |
1625 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1626 // 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
|
1627 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
|
1628 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
|
1629 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1630 _inc_cset_head = NULL; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1631 _inc_cset_tail = NULL; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1632 _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
|
1633 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1634 _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
|
1635 _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
|
1636 _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
|
1637 _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
|
1638 _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
|
1639 _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
|
1640 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1641 |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1642 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
|
1643 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
|
1644 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
|
1645 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1646 // 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
|
1647 // _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
|
1648 // 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
|
1649 // 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
|
1650 // 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
|
1651 // the "main" fields. |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1652 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1653 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
|
1654 _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
|
1655 } else { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1656 // 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
|
1657 // 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
|
1658 // 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
|
1659 // 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
|
1660 // 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
|
1661 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
|
1662 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
|
1663 _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
|
1664 } else { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1665 _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
|
1666 } |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1667 } |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1668 _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
|
1669 _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
|
1670 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1671 _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
|
1672 _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
|
1673 } |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1674 |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1675 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
|
1676 // 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
|
1677 // * 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
|
1678 // evacuation pause, |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1679 // * 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
|
1680 // 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
|
1681 // * 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
|
1682 // 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
|
1683 // 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
|
1684 // 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
|
1685 // 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
|
1686 // refine thread (RSet sampling). |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1687 |
6611 | 1688 double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1689 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
|
1690 _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
|
1691 _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
|
1692 _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
|
1693 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1694 // 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
|
1695 // 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
|
1696 // 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
|
1697 // rset sampling code |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1698 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
|
1699 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
|
1700 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1701 |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1702 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
|
1703 size_t new_rs_length) { |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1704 // 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
|
1705 assert(hr->is_young(), "Precondition"); |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1706 assert(!SafepointSynchronize::is_at_safepoint(), |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1707 "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
|
1708 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1709 // 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
|
1710 // _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
|
1711 // 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
|
1712 // 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
|
1713 // 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
|
1714 // 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
|
1715 // 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
|
1716 // 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
|
1717 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1718 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
|
1719 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
|
1720 _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
|
1721 |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1722 double old_elapsed_time_ms = hr->predicted_elapsed_time_ms(); |
6611 | 1723 double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); |
4727
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1724 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
|
1725 _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
|
1726 |
67fdcb391461
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
4710
diff
changeset
|
1727 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
|
1728 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
|
1729 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1730 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1731 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
|
1732 assert(hr->is_young(), "invariant"); |
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1733 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
|
1734 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
|
1735 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1736 // 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
|
1737 // 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
|
1738 // 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
|
1739 // 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
|
1740 // 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
|
1741 // 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
|
1742 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1743 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
|
1744 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
|
1745 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1746 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
|
1747 _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
|
1748 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1749 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
|
1750 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
|
1751 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
|
1752 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1753 _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
|
1754 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1755 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1756 // 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
|
1757 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
|
1758 // 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
|
1759 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
|
1760 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1761 // Do the 'common' stuff |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1762 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
|
1763 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1764 // 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
|
1765 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
|
1766 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
|
1767 _inc_cset_head = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1768 } else { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1769 _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
|
1770 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1771 _inc_cset_tail = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1772 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1773 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1774 // 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
|
1775 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
|
1776 // 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
|
1777 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
|
1778 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1779 // Do the 'common' stuff |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1780 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
|
1781 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1782 // 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
|
1783 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
|
1784 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
|
1785 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
|
1786 _inc_cset_tail = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1787 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1788 _inc_cset_head = hr; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1789 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1790 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1791 #ifndef PRODUCT |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1792 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
|
1793 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
|
1794 |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1795 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
|
1796 HeapRegion* csr = list_head; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1797 while (csr != NULL) { |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1798 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
|
1799 assert(csr->in_collection_set(), "bad CS"); |
6027
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
1800 st->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", |
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
1801 HR_FORMAT_PARAMS(csr), |
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
1802 csr->prev_top_at_mark_start(), csr->next_top_at_mark_start(), |
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
1803 csr->age_in_surv_rate_group_cond()); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1804 csr = next; |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1805 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1806 } |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1807 #endif // !PRODUCT |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1808 |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1809 double G1CollectorPolicy::reclaimable_bytes_perc(size_t reclaimable_bytes) { |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1810 // Returns the given amount of reclaimable bytes (that represents |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1811 // the amount of reclaimable space still to be collected) as a |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1812 // percentage of the current heap capacity. |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1813 size_t capacity_bytes = _g1->capacity(); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1814 return (double) reclaimable_bytes * 100.0 / (double) capacity_bytes; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1815 } |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1816 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1817 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
|
1818 const char* false_action_str) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1819 CollectionSetChooser* cset_chooser = _collectionSetChooser; |
6011 | 1820 if (cset_chooser->is_empty()) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1821 ergo_verbose0(ErgoMixedGCs, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1822 false_action_str, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1823 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
|
1824 return false; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1825 } |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1826 |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1827 // Is the amount of uncollected reclaimable space above G1HeapWastePercent? |
6011 | 1828 size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1829 double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); |
5964
21595f05bc93
7146246: G1: expose some of the -XX flags that drive which old regions to collect during mixed GCs
tonyp
parents:
4912
diff
changeset
|
1830 double threshold = (double) G1HeapWastePercent; |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1831 if (reclaimable_perc <= threshold) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1832 ergo_verbose4(ErgoMixedGCs, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1833 false_action_str, |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1834 ergo_format_reason("reclaimable percentage not over threshold") |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1835 ergo_format_region("candidate old regions") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1836 ergo_format_byte_perc("reclaimable") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1837 ergo_format_perc("threshold"), |
6011 | 1838 cset_chooser->remaining_regions(), |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1839 reclaimable_bytes, |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1840 reclaimable_perc, threshold); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1841 return false; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1842 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1843 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1844 ergo_verbose4(ErgoMixedGCs, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1845 true_action_str, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1846 ergo_format_reason("candidate old regions available") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1847 ergo_format_region("candidate old regions") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1848 ergo_format_byte_perc("reclaimable") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1849 ergo_format_perc("threshold"), |
6011 | 1850 cset_chooser->remaining_regions(), |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1851 reclaimable_bytes, |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1852 reclaimable_perc, threshold); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1853 return true; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1854 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1855 |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1856 uint G1CollectorPolicy::calc_min_old_cset_length() { |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1857 // The min old CSet region bound is based on the maximum desired |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1858 // number of mixed GCs after a cycle. I.e., even if some old regions |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1859 // look expensive, we should add them to the CSet anyway to make |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1860 // sure we go through the available old regions in no more than the |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1861 // maximum desired number of mixed GCs. |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1862 // |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1863 // The calculation is based on the number of marked regions we added |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1864 // to the CSet chooser in the first place, not how many remain, so |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1865 // that the result is the same during all mixed GCs that follow a cycle. |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1866 |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1867 const size_t region_num = (size_t) _collectionSetChooser->length(); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1868 const size_t gc_num = (size_t) MAX2(G1MixedGCCountTarget, (uintx) 1); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1869 size_t result = region_num / gc_num; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1870 // emulate ceiling |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1871 if (result * gc_num < region_num) { |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1872 result += 1; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1873 } |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1874 return (uint) result; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1875 } |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1876 |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1877 uint G1CollectorPolicy::calc_max_old_cset_length() { |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1878 // The max old CSet region bound is based on the threshold expressed |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1879 // as a percentage of the heap size. I.e., it should bound the |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1880 // number of old regions added to the CSet irrespective of how many |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1881 // of them are available. |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1882 |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1883 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1884 const size_t region_num = g1h->n_regions(); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1885 const size_t perc = (size_t) G1OldCSetRegionThresholdPercent; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1886 size_t result = region_num * perc / 100; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1887 // emulate ceiling |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1888 if (100 * result < region_num * perc) { |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1889 result += 1; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1890 } |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1891 return (uint) result; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1892 } |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1893 |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1894 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1895 void G1CollectorPolicy::finalize_cset(double target_pause_time_ms) { |
6611 | 1896 double young_start_time_sec = os::elapsedTime(); |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
1897 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1898 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
|
1899 finalize_incremental_cset_building(); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1900 |
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1901 guarantee(target_pause_time_ms > 0.0, |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1902 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
|
1903 target_pause_time_ms)); |
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1904 guarantee(_collection_set == NULL, "Precondition"); |
342 | 1905 |
1906 double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); | |
1907 double predicted_pause_time_ms = base_time_ms; | |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1908 double time_remaining_ms = MAX2(target_pause_time_ms - base_time_ms, 0.0); |
342 | 1909 |
6611 | 1910 ergo_verbose4(ErgoCSetConstruction | ErgoHigh, |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1911 "start choosing CSet", |
6611 | 1912 ergo_format_size("_pending_cards") |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1913 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
|
1914 ergo_format_ms("remaining time") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1915 ergo_format_ms("target pause time"), |
6611 | 1916 _pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1917 |
4710 | 1918 _last_gc_was_young = gcs_are_young() ? true : false; |
1919 | |
1920 if (_last_gc_was_young) { | |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
1921 _trace_gen0_time_data.increment_young_collection_count(); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1922 } else { |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
1923 _trace_gen0_time_data.increment_mixed_collection_count(); |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1924 } |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1925 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1926 // 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
|
1927 // 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
|
1928 // [Newly Young Regions ++ Survivors from last pause]. |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1929 |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1930 uint survivor_region_length = young_list->survivor_length(); |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1931 uint eden_region_length = young_list->length() - survivor_region_length; |
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4072
diff
changeset
|
1932 init_cset_region_lengths(eden_region_length, survivor_region_length); |
6611 | 1933 |
1934 HeapRegion* hr = young_list->first_survivor_region(); | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1935 while (hr != NULL) { |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1936 assert(hr->is_survivor(), "badly formed young list"); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1937 hr->set_young(); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1938 hr = hr->get_next_young_region(); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1939 } |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1940 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1941 // 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
|
1942 young_list->clear_survivors(); |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1943 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1944 _collection_set = _inc_cset_head; |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1945 _collection_set_bytes_used_before = _inc_cset_bytes_used_before; |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1946 time_remaining_ms = MAX2(time_remaining_ms - _inc_cset_predicted_elapsed_time_ms, 0.0); |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1947 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
|
1948 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1949 ergo_verbose3(ErgoCSetConstruction | ErgoHigh, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1950 "add young regions to CSet", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1951 ergo_format_region("eden") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1952 ergo_format_region("survivors") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1953 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
|
1954 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
|
1955 _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
|
1956 |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1957 // The number of recorded young regions is the incremental |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1958 // collection set's current size |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1959 set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1960 |
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1961 double young_end_time_sec = os::elapsedTime(); |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
1962 phase_times()->record_young_cset_choice_time_ms((young_end_time_sec - young_start_time_sec) * 1000.0); |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1963 |
6611 | 1964 // Set the start of the non-young choice time. |
1965 double non_young_start_time_sec = young_end_time_sec; | |
3867
ff53346271fe
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
3830
diff
changeset
|
1966 |
4710 | 1967 if (!gcs_are_young()) { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1968 CollectionSetChooser* cset_chooser = _collectionSetChooser; |
6011 | 1969 cset_chooser->verify(); |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1970 const uint min_old_cset_length = calc_min_old_cset_length(); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1971 const uint max_old_cset_length = calc_max_old_cset_length(); |
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1972 |
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6007
diff
changeset
|
1973 uint expensive_region_num = 0; |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1974 bool check_time_remaining = adaptive_young_list_length(); |
6611 | 1975 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1976 HeapRegion* hr = cset_chooser->peek(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1977 while (hr != NULL) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1978 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
|
1979 // 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
|
1980 ergo_verbose2(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1981 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1982 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
|
1983 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1984 ergo_format_region("max"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
1985 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
|
1986 break; |
342 | 1987 } |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
1988 |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1989 |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1990 // Stop adding regions if the remaining reclaimable space is |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1991 // not above G1HeapWastePercent. |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1992 size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1993 double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1994 double threshold = (double) G1HeapWastePercent; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1995 if (reclaimable_perc <= threshold) { |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1996 // We've added enough old regions that the amount of uncollected |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1997 // reclaimable space is at or below the waste threshold. Stop |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1998 // adding old regions to the CSet. |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
1999 ergo_verbose5(ErgoCSetConstruction, |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2000 "finish adding old regions to CSet", |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2001 ergo_format_reason("reclaimable percentage not over threshold") |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2002 ergo_format_region("old") |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2003 ergo_format_region("max") |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2004 ergo_format_byte_perc("reclaimable") |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2005 ergo_format_perc("threshold"), |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2006 old_cset_region_length(), |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2007 max_old_cset_length, |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2008 reclaimable_bytes, |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2009 reclaimable_perc, threshold); |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2010 break; |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2011 } |
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2012 |
6611 | 2013 double predicted_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2014 if (check_time_remaining) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2015 if (predicted_time_ms > time_remaining_ms) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2016 // Too expensive for the current CSet. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2017 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2018 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
|
2019 // 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
|
2020 // we are done with this CSet. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2021 ergo_verbose4(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2022 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2023 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
|
2024 ergo_format_ms("predicted time") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2025 ergo_format_ms("remaining time") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2026 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2027 ergo_format_region("min"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2028 predicted_time_ms, time_remaining_ms, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2029 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
|
2030 break; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2031 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2032 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2033 // 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
|
2034 // minimum number of old regions. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2035 expensive_region_num += 1; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2036 } |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2037 } else { |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2038 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
|
2039 // 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
|
2040 // 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
|
2041 ergo_verbose2(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2042 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2043 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
|
2044 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2045 ergo_format_region("min"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2046 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
|
2047 break; |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2048 } |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2049 } |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2050 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2051 // We will add this region to the CSet. |
8681
27714220e50e
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
8094
diff
changeset
|
2052 time_remaining_ms = MAX2(time_remaining_ms - predicted_time_ms, 0.0); |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2053 predicted_pause_time_ms += predicted_time_ms; |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2054 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
|
2055 _g1->old_set_remove(hr); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2056 add_old_region_to_cset(hr); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2057 |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2058 hr = cset_chooser->peek(); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2059 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2060 if (hr == NULL) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2061 ergo_verbose0(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2062 "finish adding old regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2063 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
|
2064 } |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2065 |
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2066 if (expensive_region_num > 0) { |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2067 // 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
|
2068 // 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
|
2069 // avoid generating output per region. |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2070 ergo_verbose4(ErgoCSetConstruction, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2071 "added expensive regions to CSet", |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2072 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
|
2073 ergo_format_region("old") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2074 ergo_format_region("expensive") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2075 ergo_format_region("min") |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2076 ergo_format_ms("remaining time"), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2077 old_cset_region_length(), |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2078 expensive_region_num, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2079 min_old_cset_length, |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2080 time_remaining_ms); |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2081 } |
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4837
diff
changeset
|
2082 |
6011 | 2083 cset_chooser->verify(); |
342 | 2084 } |
2085 | |
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2086 stop_incremental_cset_building(); |
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2087 |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2088 ergo_verbose5(ErgoCSetConstruction, |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2089 "finish choosing CSet", |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2090 ergo_format_region("eden") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2091 ergo_format_region("survivors") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2092 ergo_format_region("old") |
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2093 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
|
2094 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
|
2095 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
|
2096 old_cset_region_length(), |
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3868
diff
changeset
|
2097 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
|
2098 |
342 | 2099 double non_young_end_time_sec = os::elapsedTime(); |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2100 phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0); |
342 | 2101 } |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2102 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2103 void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2104 if(TraceGen0Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2105 _all_stop_world_times_ms.add(time_to_stop_the_world_ms); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2106 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2107 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2108 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2109 void TraceGen0TimeData::record_yield_time(double yield_time_ms) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2110 if(TraceGen0Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2111 _all_yield_times_ms.add(yield_time_ms); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2112 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2113 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2114 |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2115 void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) { |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2116 if(TraceGen0Time) { |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2117 _total.add(pause_time_ms); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2118 _other.add(pause_time_ms - phase_times->accounted_time_ms()); |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2119 _root_region_scan_wait.add(phase_times->root_region_scan_wait_time_ms()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2120 _parallel.add(phase_times->cur_collection_par_time_ms()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2121 _ext_root_scan.add(phase_times->average_last_ext_root_scan_time()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2122 _satb_filtering.add(phase_times->average_last_satb_filtering_times_ms()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2123 _update_rs.add(phase_times->average_last_update_rs_time()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2124 _scan_rs.add(phase_times->average_last_scan_rs_time()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2125 _obj_copy.add(phase_times->average_last_obj_copy_time()); |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2126 _termination.add(phase_times->average_last_termination_time()); |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2127 |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2128 double parallel_known_time = phase_times->average_last_ext_root_scan_time() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2129 phase_times->average_last_satb_filtering_times_ms() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2130 phase_times->average_last_update_rs_time() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2131 phase_times->average_last_scan_rs_time() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2132 phase_times->average_last_obj_copy_time() + |
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2133 + phase_times->average_last_termination_time(); |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2134 |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2135 double parallel_other_time = phase_times->cur_collection_par_time_ms() - parallel_known_time; |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2136 _parallel_other.add(parallel_other_time); |
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2137 _clear_ct.add(phase_times->cur_clear_ct_time_ms()); |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2138 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2139 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2140 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2141 void TraceGen0TimeData::increment_young_collection_count() { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2142 if(TraceGen0Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2143 ++_young_pause_num; |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2144 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2145 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2146 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2147 void TraceGen0TimeData::increment_mixed_collection_count() { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2148 if(TraceGen0Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2149 ++_mixed_pause_num; |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2150 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2151 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2152 |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2153 void TraceGen0TimeData::print_summary(const char* str, |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2154 const NumberSeq* seq) const { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2155 double sum = seq->sum(); |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2156 gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)", |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2157 str, sum / 1000.0, seq->avg()); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2158 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2159 |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2160 void TraceGen0TimeData::print_summary_sd(const char* str, |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2161 const NumberSeq* seq) const { |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2162 print_summary(str, seq); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2163 gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2164 "(num", seq->num(), seq->sd(), seq->maximum()); |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2165 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2166 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2167 void TraceGen0TimeData::print() const { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2168 if (!TraceGen0Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2169 return; |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2170 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2171 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2172 gclog_or_tty->print_cr("ALL PAUSES"); |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2173 print_summary_sd(" Total", &_total); |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2174 gclog_or_tty->print_cr(""); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2175 gclog_or_tty->print_cr(""); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2176 gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2177 gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2178 gclog_or_tty->print_cr(""); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2179 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2180 gclog_or_tty->print_cr("EVACUATION PAUSES"); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2181 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2182 if (_young_pause_num == 0 && _mixed_pause_num == 0) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2183 gclog_or_tty->print_cr("none"); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2184 } else { |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2185 print_summary_sd(" Evacuation Pauses", &_total); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2186 print_summary(" Root Region Scan Wait", &_root_region_scan_wait); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2187 print_summary(" Parallel Time", &_parallel); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2188 print_summary(" Ext Root Scanning", &_ext_root_scan); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2189 print_summary(" SATB Filtering", &_satb_filtering); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2190 print_summary(" Update RS", &_update_rs); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2191 print_summary(" Scan RS", &_scan_rs); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2192 print_summary(" Object Copy", &_obj_copy); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2193 print_summary(" Termination", &_termination); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2194 print_summary(" Parallel Other", &_parallel_other); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2195 print_summary(" Clear CT", &_clear_ct); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2196 print_summary(" Other", &_other); |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2197 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2198 gclog_or_tty->print_cr(""); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2199 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2200 gclog_or_tty->print_cr("MISC"); |
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2201 print_summary_sd(" Stop World", &_all_stop_world_times_ms); |
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6109
diff
changeset
|
2202 print_summary_sd(" Yields", &_all_yield_times_ms); |
6109
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2203 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2204 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2205 void TraceGen1TimeData::record_full_collection(double full_gc_time_ms) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2206 if (TraceGen1Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2207 _all_full_gc_times.add(full_gc_time_ms); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2208 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2209 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2210 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2211 void TraceGen1TimeData::print() const { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2212 if (!TraceGen1Time) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2213 return; |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2214 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2215 |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2216 if (_all_full_gc_times.num() > 0) { |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2217 gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2218 _all_full_gc_times.num(), |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2219 _all_full_gc_times.sum() / 1000.0); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2220 gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times.avg()); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2221 gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2222 _all_full_gc_times.sd(), |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2223 _all_full_gc_times.maximum()); |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2224 } |
bbc900c2482a
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
6064
diff
changeset
|
2225 } |