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