author | brutisso |
Thu, 02 Apr 2015 06:42:24 +0200 | |
changeset 30147 | af9a41999c6e |
parent 29795 | 984c5c379c6a |
child 30272 | 8cbe337a692c |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
28483
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
2 |
* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. |
1374 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5350
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5350
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5350
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
25 |
#ifndef __clang_major__ |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
26 |
// FIXME, formats have issues. Disable this macro definition, compile, and study warnings for more information. |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
27 |
#define ATTRIBUTE_PRINTF(x,y) |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
28 |
#endif |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
29 |
|
7397 | 30 |
#include "precompiled.hpp" |
31 |
#include "gc_implementation/g1/concurrentG1Refine.hpp" |
|
32 |
#include "gc_implementation/g1/concurrentMark.hpp" |
|
33 |
#include "gc_implementation/g1/concurrentMarkThread.inline.hpp" |
|
34 |
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
|
35 |
#include "gc_implementation/g1/g1CollectorPolicy.hpp" |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
36 |
#include "gc_implementation/g1/g1ErgoVerbose.hpp" |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
37 |
#include "gc_implementation/g1/g1GCPhaseTimes.hpp" |
12378
ed44b9ecfa2f
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
12272
diff
changeset
|
38 |
#include "gc_implementation/g1/g1Log.hpp" |
7397 | 39 |
#include "gc_implementation/g1/heapRegionRemSet.hpp" |
40 |
#include "gc_implementation/shared/gcPolicyCounters.hpp" |
|
41 |
#include "runtime/arguments.hpp" |
|
42 |
#include "runtime/java.hpp" |
|
43 |
#include "runtime/mutexLocker.hpp" |
|
44 |
#include "utilities/debug.hpp" |
|
1374 | 45 |
|
46 |
// Different defaults for different number of GC threads |
|
47 |
// They were chosen by running GCOld and SPECjbb on debris with different |
|
48 |
// numbers of GC threads and choosing them based on the results |
|
49 |
||
50 |
// all the same |
|
51 |
static double rs_length_diff_defaults[] = { |
|
52 |
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 |
|
53 |
}; |
|
54 |
||
55 |
static double cost_per_card_ms_defaults[] = { |
|
56 |
0.01, 0.005, 0.005, 0.003, 0.003, 0.002, 0.002, 0.0015 |
|
57 |
}; |
|
58 |
||
59 |
// all the same |
|
11249 | 60 |
static double young_cards_per_entry_ratio_defaults[] = { |
1374 | 61 |
1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 |
62 |
}; |
|
63 |
||
64 |
static double cost_per_entry_ms_defaults[] = { |
|
65 |
0.015, 0.01, 0.01, 0.008, 0.008, 0.0055, 0.0055, 0.005 |
|
66 |
}; |
|
67 |
||
68 |
static double cost_per_byte_ms_defaults[] = { |
|
69 |
0.00006, 0.00003, 0.00003, 0.000015, 0.000015, 0.00001, 0.00001, 0.000009 |
|
70 |
}; |
|
71 |
||
72 |
// these should be pretty consistent |
|
73 |
static double constant_other_time_ms_defaults[] = { |
|
74 |
5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 |
|
75 |
}; |
|
76 |
||
77 |
||
78 |
static double young_other_cost_per_region_ms_defaults[] = { |
|
79 |
0.3, 0.2, 0.2, 0.15, 0.15, 0.12, 0.12, 0.1 |
|
80 |
}; |
|
81 |
||
82 |
static double non_young_other_cost_per_region_ms_defaults[] = { |
|
83 |
1.0, 0.7, 0.7, 0.5, 0.5, 0.42, 0.42, 0.30 |
|
84 |
}; |
|
85 |
||
86 |
G1CollectorPolicy::G1CollectorPolicy() : |
|
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27009
diff
changeset
|
87 |
_parallel_gc_threads(ParallelGCThreads), |
6759
67b1a69ef5aa
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
6449
diff
changeset
|
88 |
|
1374 | 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)), |
|
11249 | 99 |
_young_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), |
100 |
_mixed_cards_per_entry_ratio_seq(new TruncatedSeq(TruncatedSeqLength)), |
|
1374 | 101 |
_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
11249 | 102 |
_mixed_cost_per_entry_ms_seq(new TruncatedSeq(TruncatedSeqLength)), |
1374 | 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 |
||
2741 | 113 |
_pause_time_target_ms((double) MaxGCPauseMillis), |
1374 | 114 |
|
11249 | 115 |
_gcs_are_young(true), |
1374 | 116 |
|
117 |
_during_marking(false), |
|
118 |
_in_marking_window(false), |
|
119 |
_in_marking_window_im(false), |
|
120 |
||
11249 | 121 |
_recent_prev_end_times_for_all_gcs_sec( |
122 |
new TruncatedSeq(NumPrevPausesForHeuristics)), |
|
1374 | 123 |
|
124 |
_recent_avg_pause_time_ratio(0.0), |
|
125 |
||
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
126 |
_initiate_conc_mark_if_possible(false), |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
127 |
_during_initial_mark_pause(false), |
11249 | 128 |
_last_young_gc(false), |
129 |
_last_gc_was_young(false), |
|
1374 | 130 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
131 |
_eden_used_bytes_before_gc(0), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
132 |
_survivor_used_bytes_before_gc(0), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
133 |
_heap_used_bytes_before_gc(0), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
134 |
_metaspace_used_bytes_before_gc(0), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
135 |
_eden_capacity_bytes_before_gc(0), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
136 |
_heap_capacity_bytes_before_gc(0), |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
137 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
138 |
_eden_cset_region_length(0), |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
139 |
_survivor_cset_region_length(0), |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
140 |
_old_cset_region_length(0), |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
141 |
|
28832
4c2704386850
8068942: Improve validation of -XX:G1ConfidencePercent value
kbarrett
parents:
28483
diff
changeset
|
142 |
_sigma(G1ConfidencePercent / 100.0), |
4c2704386850
8068942: Improve validation of -XX:G1ConfidencePercent value
kbarrett
parents:
28483
diff
changeset
|
143 |
|
1374 | 144 |
_collection_set(NULL), |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
145 |
_collection_set_bytes_used_before(0), |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
146 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
147 |
// Incremental CSet attributes |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
148 |
_inc_cset_build_state(Inactive), |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
149 |
_inc_cset_head(NULL), |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
150 |
_inc_cset_tail(NULL), |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
151 |
_inc_cset_bytes_used_before(0), |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
152 |
_inc_cset_max_finger(NULL), |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
153 |
_inc_cset_recorded_rs_lengths(0), |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
154 |
_inc_cset_recorded_rs_lengths_diffs(0), |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
155 |
_inc_cset_predicted_elapsed_time_ms(0.0), |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
156 |
_inc_cset_predicted_elapsed_time_ms_diffs(0.0), |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
157 |
|
1374 | 158 |
// add here any more surv rate groups |
2009 | 159 |
_recorded_survivor_regions(0), |
160 |
_recorded_survivor_head(NULL), |
|
161 |
_recorded_survivor_tail(NULL), |
|
5240 | 162 |
_survivors_age_table(true), |
163 |
||
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
164 |
_gc_overhead_perc(0.0) { |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
165 |
|
28832
4c2704386850
8068942: Improve validation of -XX:G1ConfidencePercent value
kbarrett
parents:
28483
diff
changeset
|
166 |
// SurvRateGroups below must be initialized after '_sigma' because they |
4c2704386850
8068942: Improve validation of -XX:G1ConfidencePercent value
kbarrett
parents:
28483
diff
changeset
|
167 |
// indirectly access '_sigma' through this object passed to their constructor. |
28483
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
168 |
_short_lived_surv_rate_group = |
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
169 |
new SurvRateGroup(this, "Short Lived", G1YoungSurvRateNumRegionsSummary); |
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
170 |
_survivor_surv_rate_group = |
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
171 |
new SurvRateGroup(this, "Survivor", G1YoungSurvRateNumRegionsSummary); |
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
172 |
|
3697
ea9211aa02f5
6819085: G1: use larger and/or user settable region size
tonyp
parents:
3691
diff
changeset
|
173 |
// Set up the region size and associated fields. Given that the |
ea9211aa02f5
6819085: G1: use larger and/or user settable region size
tonyp
parents:
3691
diff
changeset
|
174 |
// policy is created before the heap, we have to set this up here, |
ea9211aa02f5
6819085: G1: use larger and/or user settable region size
tonyp
parents:
3691
diff
changeset
|
175 |
// so it's done as soon as possible. |
19728
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
176 |
|
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
177 |
// It would have been natural to pass initial_heap_byte_size() and |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
178 |
// max_heap_byte_size() to setup_heap_region_size() but those have |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
179 |
// not been set up at this point since they should be aligned with |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
180 |
// the region size. So, there is a circular dependency here. We base |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
181 |
// the region size on the heap size, but the heap size should be |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
182 |
// aligned with the region size. To get around this we use the |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
183 |
// unaligned values for the heap. |
9e1556506d2d
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
19546
diff
changeset
|
184 |
HeapRegion::setup_heap_region_size(InitialHeapSize, MaxHeapSize); |
4902
991aaddb5165
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
4481
diff
changeset
|
185 |
HeapRegionRemSet::setup_remset_size(); |
3697
ea9211aa02f5
6819085: G1: use larger and/or user settable region size
tonyp
parents:
3691
diff
changeset
|
186 |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
187 |
G1ErgoVerbose::initialize(); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
188 |
if (PrintAdaptiveSizePolicy) { |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
189 |
// Currently, we only use a single switch for all the heuristics. |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
190 |
G1ErgoVerbose::set_enabled(true); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
191 |
// Given that we don't currently have a verboseness level |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
192 |
// parameter, we'll hardcode this to high. This can be easily |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
193 |
// changed in the future. |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
194 |
G1ErgoVerbose::set_level(ErgoHigh); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
195 |
} else { |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
196 |
G1ErgoVerbose::set_enabled(false); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
197 |
} |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
198 |
|
5347
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
199 |
// Verify PLAB sizes |
10677
370a8da2d63f
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
10673
diff
changeset
|
200 |
const size_t region_size = HeapRegion::GrainWords; |
5347
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
201 |
if (YoungPLABSize > region_size || OldPLABSize > region_size) { |
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
202 |
char buffer[128]; |
10677
370a8da2d63f
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
10673
diff
changeset
|
203 |
jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT, |
5347
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
204 |
OldPLABSize > region_size ? "Old" : "Young", region_size); |
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
205 |
vm_exit_during_initialization(buffer); |
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
206 |
} |
1de2255c6c2e
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
5344
diff
changeset
|
207 |
|
1374 | 208 |
_recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); |
209 |
_prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; |
|
210 |
||
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
211 |
_phase_times = new G1GCPhaseTimes(_parallel_gc_threads); |
1374 | 212 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
213 |
int index = MIN2(_parallel_gc_threads - 1, 7); |
1374 | 214 |
|
215 |
_rs_length_diff_seq->add(rs_length_diff_defaults[index]); |
|
216 |
_cost_per_card_ms_seq->add(cost_per_card_ms_defaults[index]); |
|
11249 | 217 |
_young_cards_per_entry_ratio_seq->add( |
218 |
young_cards_per_entry_ratio_defaults[index]); |
|
1374 | 219 |
_cost_per_entry_ms_seq->add(cost_per_entry_ms_defaults[index]); |
220 |
_cost_per_byte_ms_seq->add(cost_per_byte_ms_defaults[index]); |
|
221 |
_constant_other_time_ms_seq->add(constant_other_time_ms_defaults[index]); |
|
222 |
_young_other_cost_per_region_ms_seq->add( |
|
223 |
young_other_cost_per_region_ms_defaults[index]); |
|
224 |
_non_young_other_cost_per_region_ms_seq->add( |
|
225 |
non_young_other_cost_per_region_ms_defaults[index]); |
|
226 |
||
5890
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
227 |
// Below, we might need to calculate the pause time target based on |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
228 |
// the pause interval. When we do so we are going to give G1 maximum |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
229 |
// flexibility and allow it to do pauses when it needs to. So, we'll |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
230 |
// arrange that the pause interval to be pause time target + 1 to |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
231 |
// ensure that a) the pause time target is maximized with respect to |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
232 |
// the pause interval and b) we maintain the invariant that pause |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
233 |
// time target < pause interval. If the user does not want this |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
234 |
// maximum flexibility, they will have to set the pause interval |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
235 |
// explicitly. |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
236 |
|
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
237 |
// First make sure that, if either parameter is set, its value is |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
238 |
// reasonable. |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
239 |
if (!FLAG_IS_DEFAULT(MaxGCPauseMillis)) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
240 |
if (MaxGCPauseMillis < 1) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
241 |
vm_exit_during_initialization("MaxGCPauseMillis should be " |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
242 |
"greater than 0"); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
243 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
244 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
245 |
if (!FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
246 |
if (GCPauseIntervalMillis < 1) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
247 |
vm_exit_during_initialization("GCPauseIntervalMillis should be " |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
248 |
"greater than 0"); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
249 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
250 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
251 |
|
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
252 |
// Then, if the pause time target parameter was not set, set it to |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
253 |
// the default value. |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
254 |
if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
255 |
if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
256 |
// The default pause time target in G1 is 200ms |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
257 |
FLAG_SET_DEFAULT(MaxGCPauseMillis, 200); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
258 |
} else { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
259 |
// We do not allow the pause interval to be set without the |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
260 |
// pause time target |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
261 |
vm_exit_during_initialization("GCPauseIntervalMillis cannot be set " |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
262 |
"without setting MaxGCPauseMillis"); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
263 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
264 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
265 |
|
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
266 |
// Then, if the interval parameter was not set, set it according to |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
267 |
// the pause time target (this will also deal with the case when the |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
268 |
// pause time target is the default value). |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
269 |
if (FLAG_IS_DEFAULT(GCPauseIntervalMillis)) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
270 |
FLAG_SET_DEFAULT(GCPauseIntervalMillis, MaxGCPauseMillis + 1); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
271 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
272 |
|
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
273 |
// Finally, make sure that the two parameters are consistent. |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
274 |
if (MaxGCPauseMillis >= GCPauseIntervalMillis) { |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
275 |
char buffer[256]; |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
276 |
jio_snprintf(buffer, 256, |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
277 |
"MaxGCPauseMillis (%u) should be less than " |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
278 |
"GCPauseIntervalMillis (%u)", |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
279 |
MaxGCPauseMillis, GCPauseIntervalMillis); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
280 |
vm_exit_during_initialization(buffer); |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
281 |
} |
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
282 |
|
2741 | 283 |
double max_gc_time = (double) MaxGCPauseMillis / 1000.0; |
5890
5766abbf8789
6949307: G1: raise a vm error, do not core dump, if target pause time and target interval are inconsistent
tonyp
parents:
5702
diff
changeset
|
284 |
double time_slice = (double) GCPauseIntervalMillis / 1000.0; |
1374 | 285 |
_mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time); |
15806
f3fb856749cf
8008546: Wrong G1ConfidencePercent results in GUARANTEE(VARIANCE() > -1.0) FAILED
poonam
parents:
15089
diff
changeset
|
286 |
|
1374 | 287 |
// start conservatively (around 50ms is about right) |
288 |
_concurrent_mark_remark_times_ms->add(0.05); |
|
289 |
_concurrent_mark_cleanup_times_ms->add(0.20); |
|
290 |
_tenuring_threshold = MaxTenuringThreshold; |
|
10281
ad7517425333
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
10280
diff
changeset
|
291 |
// _max_survivor_regions will be calculated by |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
292 |
// update_young_list_target_length() during initialization. |
10281
ad7517425333
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
10280
diff
changeset
|
293 |
_max_survivor_regions = 0; |
2009 | 294 |
|
5240 | 295 |
assert(GCTimeRatio > 0, |
296 |
"we should have set it to a default value set_g1_gc_flags() " |
|
297 |
"if a user set it to 0"); |
|
298 |
_gc_overhead_perc = 100.0 * (1.0 / (1.0 + GCTimeRatio)); |
|
299 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
300 |
uintx reserve_perc = G1ReservePercent; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
301 |
// Put an artificial ceiling on this so that it's not set to a silly value. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
302 |
if (reserve_perc > 50) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
303 |
reserve_perc = 50; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
304 |
warning("G1ReservePercent is set to a value that is too large, " |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
305 |
"it's been updated to %u", reserve_perc); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
306 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
307 |
_reserve_factor = (double) reserve_perc / 100.0; |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
308 |
// This will be set when the heap is expanded |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
309 |
// for the first time during initialization. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
310 |
_reserve_regions = 0; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
311 |
|
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
312 |
_collectionSetChooser = new CollectionSetChooser(); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
313 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
314 |
|
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
315 |
void G1CollectorPolicy::initialize_alignments() { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
316 |
_space_alignment = HeapRegion::GrainBytes; |
22548
d54e4339811f
8031776: Remove the unnecessary enum GenRemSet::Name
ehelin
parents:
21561
diff
changeset
|
317 |
size_t card_table_alignment = GenRemSet::max_alignment_constraint(); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
318 |
size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size(); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
319 |
_heap_alignment = MAX3(card_table_alignment, _space_alignment, page_size); |
1374 | 320 |
} |
321 |
||
322 |
void G1CollectorPolicy::initialize_flags() { |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
323 |
if (G1HeapRegionSize != HeapRegion::GrainBytes) { |
29697
92501504191b
8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents:
29680
diff
changeset
|
324 |
FLAG_SET_ERGO(size_t, G1HeapRegionSize, HeapRegion::GrainBytes); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
325 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
326 |
|
2011
d666454081dd
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
2009
diff
changeset
|
327 |
if (SurvivorRatio < 1) { |
d666454081dd
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
2009
diff
changeset
|
328 |
vm_exit_during_initialization("Invalid survivor ratio specified"); |
d666454081dd
6802413: G1: G1FixedSurvivorSpaceSize should be converted into regions in calculate_survivors_policy()
apetrusenko
parents:
2009
diff
changeset
|
329 |
} |
1374 | 330 |
CollectorPolicy::initialize_flags(); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
331 |
_young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags |
1374 | 332 |
} |
333 |
||
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
334 |
void G1CollectorPolicy::post_heap_initialize() { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
335 |
uintx max_regions = G1CollectedHeap::heap()->max_regions(); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
336 |
size_t max_young_size = (size_t)_young_gen_sizer->max_young_length(max_regions) * HeapRegion::GrainBytes; |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
337 |
if (max_young_size != MaxNewSize) { |
29697
92501504191b
8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents:
29680
diff
changeset
|
338 |
FLAG_SET_ERGO(size_t, MaxNewSize, max_young_size); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
339 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
340 |
} |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
341 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
342 |
G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true), |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
343 |
_min_desired_young_length(0), _max_desired_young_length(0) { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
344 |
if (FLAG_IS_CMDLINE(NewRatio)) { |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
345 |
if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) { |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
346 |
warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio"); |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
347 |
} else { |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
348 |
_sizer_kind = SizerNewRatio; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
349 |
_adaptive_size = false; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
350 |
return; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
351 |
} |
10667 | 352 |
} |
5036
7b652cd72d65
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
5034
diff
changeset
|
353 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
354 |
if (NewSize > MaxNewSize) { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
355 |
if (FLAG_IS_CMDLINE(MaxNewSize)) { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
356 |
warning("NewSize (" SIZE_FORMAT "k) is greater than the MaxNewSize (" SIZE_FORMAT "k). " |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
357 |
"A new max generation size of " SIZE_FORMAT "k will be used.", |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
358 |
NewSize/K, MaxNewSize/K, NewSize/K); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
359 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
360 |
MaxNewSize = NewSize; |
20721
b134465e8682
8023643: G1 assert failed when NewSize was specified greater than MaxNewSize
jwilhelm
parents:
20398
diff
changeset
|
361 |
} |
b134465e8682
8023643: G1 assert failed when NewSize was specified greater than MaxNewSize
jwilhelm
parents:
20398
diff
changeset
|
362 |
|
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
363 |
if (FLAG_IS_CMDLINE(NewSize)) { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
364 |
_min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
365 |
1U); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
366 |
if (FLAG_IS_CMDLINE(MaxNewSize)) { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
367 |
_max_desired_young_length = |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
368 |
MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
369 |
1U); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
370 |
_sizer_kind = SizerMaxAndNewSize; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
371 |
_adaptive_size = _min_desired_young_length == _max_desired_young_length; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
372 |
} else { |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
373 |
_sizer_kind = SizerNewSizeOnly; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
374 |
} |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
375 |
} else if (FLAG_IS_CMDLINE(MaxNewSize)) { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
376 |
_max_desired_young_length = |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
377 |
MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes), |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
378 |
1U); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
379 |
_sizer_kind = SizerMaxNewSizeOnly; |
5036
7b652cd72d65
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
5034
diff
changeset
|
380 |
} |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
381 |
} |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
382 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
383 |
uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) { |
15089 | 384 |
uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
385 |
return MAX2(1U, default_value); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
386 |
} |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
387 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
388 |
uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { |
15089 | 389 |
uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
390 |
return MAX2(1U, default_value); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
391 |
} |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
392 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
393 |
void G1YoungGenSizer::recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length) { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
394 |
assert(number_of_heap_regions > 0, "Heap must be initialized"); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
395 |
|
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
396 |
switch (_sizer_kind) { |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
397 |
case SizerDefaults: |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
398 |
*min_young_length = calculate_default_min_length(number_of_heap_regions); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
399 |
*max_young_length = calculate_default_max_length(number_of_heap_regions); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
400 |
break; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
401 |
case SizerNewSizeOnly: |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
402 |
*max_young_length = calculate_default_max_length(number_of_heap_regions); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
403 |
*max_young_length = MAX2(*min_young_length, *max_young_length); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
404 |
break; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
405 |
case SizerMaxNewSizeOnly: |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
406 |
*min_young_length = calculate_default_min_length(number_of_heap_regions); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
407 |
*min_young_length = MIN2(*min_young_length, *max_young_length); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
408 |
break; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
409 |
case SizerMaxAndNewSize: |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
410 |
// Do nothing. Values set on the command line, don't update them at runtime. |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
411 |
break; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
412 |
case SizerNewRatio: |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
413 |
*min_young_length = number_of_heap_regions / (NewRatio + 1); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
414 |
*max_young_length = *min_young_length; |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
415 |
break; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
416 |
default: |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
417 |
ShouldNotReachHere(); |
5036
7b652cd72d65
6928065: G1: use existing command line parameters to set the young generation size
tonyp
parents:
5034
diff
changeset
|
418 |
} |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
419 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
420 |
assert(*min_young_length <= *max_young_length, "Invalid min/max young gen size values"); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
421 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
422 |
|
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
423 |
uint G1YoungGenSizer::max_young_length(uint number_of_heap_regions) { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
424 |
// We need to pass the desired values because recalculation may not update these |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
425 |
// values in some cases. |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
426 |
uint temp = _min_desired_young_length; |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
427 |
uint result = _max_desired_young_length; |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
428 |
recalculate_min_max_young_length(number_of_heap_regions, &temp, &result); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
429 |
return result; |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
430 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
431 |
|
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
432 |
void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
433 |
recalculate_min_max_young_length(new_number_of_heap_regions, &_min_desired_young_length, |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
434 |
&_max_desired_young_length); |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
435 |
} |
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
436 |
|
1374 | 437 |
void G1CollectorPolicy::init() { |
438 |
// Set aside an initial future to_space. |
|
439 |
_g1 = G1CollectedHeap::heap(); |
|
440 |
||
441 |
assert(Heap_lock->owned_by_self(), "Locking discipline."); |
|
442 |
||
2009 | 443 |
initialize_gc_policy_counters(); |
444 |
||
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
445 |
if (adaptive_young_list_length()) { |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
446 |
_young_list_fixed_length = 0; |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
447 |
} else { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
448 |
_young_list_fixed_length = _young_gen_sizer->min_desired_young_length(); |
1374 | 449 |
} |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
450 |
_free_regions_at_end_of_collection = _g1->num_free_regions(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
451 |
update_young_list_target_length(); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
452 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
453 |
// We may immediately start allocating regions and placing them on the |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
454 |
// collection set list. Initialize the per-collection set info |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
455 |
start_incremental_cset_building(); |
1374 | 456 |
} |
457 |
||
2009 | 458 |
// Create the jstat counters for the policy. |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
459 |
void G1CollectorPolicy::initialize_gc_policy_counters() { |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
460 |
_gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3); |
2009 | 461 |
} |
462 |
||
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
463 |
bool G1CollectorPolicy::predict_will_fit(uint young_length, |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
464 |
double base_time_ms, |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
465 |
uint base_free_regions, |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
466 |
double target_pause_time_ms) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
467 |
if (young_length >= base_free_regions) { |
1374 | 468 |
// end condition 1: not enough space for the young regions |
469 |
return false; |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
470 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
471 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
472 |
double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1); |
1374 | 473 |
size_t bytes_to_copy = |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
474 |
(size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); |
1374 | 475 |
double copy_time_ms = predict_object_copy_time_ms(bytes_to_copy); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
476 |
double young_other_time_ms = predict_young_other_time_ms(young_length); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
477 |
double pause_time_ms = base_time_ms + copy_time_ms + young_other_time_ms; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
478 |
if (pause_time_ms > target_pause_time_ms) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
479 |
// end condition 2: prediction is over the target pause time |
1374 | 480 |
return false; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
481 |
} |
1374 | 482 |
|
483 |
size_t free_bytes = |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
484 |
(base_free_regions - young_length) * HeapRegion::GrainBytes; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
485 |
if ((2.0 * sigma()) * (double) bytes_to_copy > (double) free_bytes) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
486 |
// end condition 3: out-of-space (conservatively!) |
1374 | 487 |
return false; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
488 |
} |
1374 | 489 |
|
490 |
// success! |
|
491 |
return true; |
|
492 |
} |
|
493 |
||
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
494 |
void G1CollectorPolicy::record_new_heap_size(uint new_number_of_regions) { |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
495 |
// re-calculate the necessary reserve |
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
496 |
double reserve_regions_d = (double) new_number_of_regions * _reserve_factor; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
497 |
// We use ceiling so that if reserve_regions_d is > 0.0 (but |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
498 |
// smaller than 1.0) we'll get 1. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
499 |
_reserve_regions = (uint) ceil(reserve_regions_d); |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
500 |
|
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
501 |
_young_gen_sizer->heap_size_changed(new_number_of_regions); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
502 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
503 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
504 |
uint G1CollectorPolicy::calculate_young_list_desired_min_length( |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
505 |
uint base_min_length) { |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
506 |
uint desired_min_length = 0; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
507 |
if (adaptive_young_list_length()) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
508 |
if (_alloc_rate_ms_seq->num() > 3) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
509 |
double now_sec = os::elapsedTime(); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
510 |
double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
511 |
double alloc_rate_ms = predict_alloc_rate_ms(); |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
512 |
desired_min_length = (uint) ceil(alloc_rate_ms * when_ms); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
513 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
514 |
// otherwise we don't have enough info to make the prediction |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
515 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
516 |
} |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
517 |
desired_min_length += base_min_length; |
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
518 |
// make sure we don't go below any user-defined minimum bound |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
519 |
return MAX2(_young_gen_sizer->min_desired_young_length(), desired_min_length); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
520 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
521 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
522 |
uint G1CollectorPolicy::calculate_young_list_desired_max_length() { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
523 |
// Here, we might want to also take into account any additional |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
524 |
// constraints (i.e., user-defined minimum bound). Currently, we |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
525 |
// effectively don't set this bound. |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11396
diff
changeset
|
526 |
return _young_gen_sizer->max_desired_young_length(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
527 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
528 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
529 |
void G1CollectorPolicy::update_young_list_target_length(size_t rs_lengths) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
530 |
if (rs_lengths == (size_t) -1) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
531 |
// if it's set to the default value (-1), we should predict it; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
532 |
// otherwise, use the given value. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
533 |
rs_lengths = (size_t) get_new_prediction(_rs_lengths_seq); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
534 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
535 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
536 |
// Calculate the absolute and desired min bounds. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
537 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
538 |
// This is how many young regions we already have (currently: the survivors). |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
539 |
uint base_min_length = recorded_survivor_regions(); |
29465
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
540 |
uint desired_min_length = calculate_young_list_desired_min_length(base_min_length); |
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
541 |
// This is the absolute minimum young length. Ensure that we |
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
542 |
// will at least have one eden region available for allocation. |
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
543 |
uint absolute_min_length = base_min_length + MAX2(_g1->young_list()->eden_length(), (uint)1); |
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
544 |
// If we shrank the young list target it should not shrink below the current size. |
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
545 |
desired_min_length = MAX2(desired_min_length, absolute_min_length); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
546 |
// Calculate the absolute and desired max bounds. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
547 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
548 |
// We will try our best not to "eat" into the reserve. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
549 |
uint absolute_max_length = 0; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
550 |
if (_free_regions_at_end_of_collection > _reserve_regions) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
551 |
absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
552 |
} |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
553 |
uint desired_max_length = calculate_young_list_desired_max_length(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
554 |
if (desired_max_length > absolute_max_length) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
555 |
desired_max_length = absolute_max_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
556 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
557 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
558 |
uint young_list_target_length = 0; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
559 |
if (adaptive_young_list_length()) { |
11249 | 560 |
if (gcs_are_young()) { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
561 |
young_list_target_length = |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
562 |
calculate_young_list_target_length(rs_lengths, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
563 |
base_min_length, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
564 |
desired_min_length, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
565 |
desired_max_length); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
566 |
_rs_lengths_prediction = rs_lengths; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
567 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
568 |
// Don't calculate anything and let the code below bound it to |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
569 |
// the desired_min_length, i.e., do the next GC as soon as |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
570 |
// possible to maximize how many old regions we can add to it. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
571 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
572 |
} else { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
573 |
// The user asked for a fixed young gen so we'll fix the young gen |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
574 |
// whether the next GC is young or mixed. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
575 |
young_list_target_length = _young_list_fixed_length; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
576 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
577 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
578 |
// Make sure we don't go over the desired max length, nor under the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
579 |
// desired min length. In case they clash, desired_min_length wins |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
580 |
// which is why that test is second. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
581 |
if (young_list_target_length > desired_max_length) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
582 |
young_list_target_length = desired_max_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
583 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
584 |
if (young_list_target_length < desired_min_length) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
585 |
young_list_target_length = desired_min_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
586 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
587 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
588 |
assert(young_list_target_length > recorded_survivor_regions(), |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
589 |
"we should be able to allocate at least one eden region"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
590 |
assert(young_list_target_length >= absolute_min_length, "post-condition"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
591 |
_young_list_target_length = young_list_target_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
592 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
593 |
update_max_gc_locker_expansion(); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
594 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
595 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
596 |
uint |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
597 |
G1CollectorPolicy::calculate_young_list_target_length(size_t rs_lengths, |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
598 |
uint base_min_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
599 |
uint desired_min_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
600 |
uint desired_max_length) { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
601 |
assert(adaptive_young_list_length(), "pre-condition"); |
11249 | 602 |
assert(gcs_are_young(), "only call this for young GCs"); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
603 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
604 |
// In case some edge-condition makes the desired max length too small... |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
605 |
if (desired_max_length <= desired_min_length) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
606 |
return desired_min_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
607 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
608 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
609 |
// We'll adjust min_young_length and max_young_length not to include |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
610 |
// the already allocated young regions (i.e., so they reflect the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
611 |
// min and max eden regions we'll allocate). The base_min_length |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
612 |
// will be reflected in the predictions by the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
613 |
// survivor_regions_evac_time prediction. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
614 |
assert(desired_min_length > base_min_length, "invariant"); |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
615 |
uint min_young_length = desired_min_length - base_min_length; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
616 |
assert(desired_max_length > base_min_length, "invariant"); |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
617 |
uint max_young_length = desired_max_length - base_min_length; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
618 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
619 |
double target_pause_time_ms = _mmu_tracker->max_gc_time() * 1000.0; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
620 |
double survivor_regions_evac_time = predict_survivor_regions_evac_time(); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
621 |
size_t pending_cards = (size_t) get_new_prediction(_pending_cards_seq); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
622 |
size_t adj_rs_lengths = rs_lengths + predict_rs_length_diff(); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
623 |
size_t scanned_cards = predict_young_card_num(adj_rs_lengths); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
624 |
double base_time_ms = |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
625 |
predict_base_elapsed_time_ms(pending_cards, scanned_cards) + |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
626 |
survivor_regions_evac_time; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
627 |
uint available_free_regions = _free_regions_at_end_of_collection; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
628 |
uint base_free_regions = 0; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
629 |
if (available_free_regions > _reserve_regions) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
630 |
base_free_regions = available_free_regions - _reserve_regions; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
631 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
632 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
633 |
// Here, we will make sure that the shortest young length that |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
634 |
// makes sense fits within the target pause time. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
635 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
636 |
if (predict_will_fit(min_young_length, base_time_ms, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
637 |
base_free_regions, target_pause_time_ms)) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
638 |
// The shortest young length will fit into the target pause time; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
639 |
// we'll now check whether the absolute maximum number of young |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
640 |
// regions will fit in the target pause time. If not, we'll do |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
641 |
// a binary search between min_young_length and max_young_length. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
642 |
if (predict_will_fit(max_young_length, base_time_ms, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
643 |
base_free_regions, target_pause_time_ms)) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
644 |
// The maximum young length will fit into the target pause time. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
645 |
// We are done so set min young length to the maximum length (as |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
646 |
// the result is assumed to be returned in min_young_length). |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
647 |
min_young_length = max_young_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
648 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
649 |
// The maximum possible number of young regions will not fit within |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
650 |
// the target pause time so we'll search for the optimal |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
651 |
// length. The loop invariants are: |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
652 |
// |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
653 |
// min_young_length < max_young_length |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
654 |
// min_young_length is known to fit into the target pause time |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
655 |
// max_young_length is known not to fit into the target pause time |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
656 |
// |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
657 |
// Going into the loop we know the above hold as we've just |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
658 |
// checked them. Every time around the loop we check whether |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
659 |
// the middle value between min_young_length and |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
660 |
// max_young_length fits into the target pause time. If it |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
661 |
// does, it becomes the new min. If it doesn't, it becomes |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
662 |
// the new max. This way we maintain the loop invariants. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
663 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
664 |
assert(min_young_length < max_young_length, "invariant"); |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
665 |
uint diff = (max_young_length - min_young_length) / 2; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
666 |
while (diff > 0) { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
667 |
uint young_length = min_young_length + diff; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
668 |
if (predict_will_fit(young_length, base_time_ms, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
669 |
base_free_regions, target_pause_time_ms)) { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
670 |
min_young_length = young_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
671 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
672 |
max_young_length = young_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
673 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
674 |
assert(min_young_length < max_young_length, "invariant"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
675 |
diff = (max_young_length - min_young_length) / 2; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
676 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
677 |
// The results is min_young_length which, according to the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
678 |
// loop invariants, should fit within the target pause time. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
679 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
680 |
// These are the post-conditions of the binary search above: |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
681 |
assert(min_young_length < max_young_length, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
682 |
"otherwise we should have discovered that max_young_length " |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
683 |
"fits into the pause target and not done the binary search"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
684 |
assert(predict_will_fit(min_young_length, base_time_ms, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
685 |
base_free_regions, target_pause_time_ms), |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
686 |
"min_young_length, the result of the binary search, should " |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
687 |
"fit into the pause target"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
688 |
assert(!predict_will_fit(min_young_length + 1, base_time_ms, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
689 |
base_free_regions, target_pause_time_ms), |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
690 |
"min_young_length, the result of the binary search, should be " |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
691 |
"optimal, so no larger length should fit into the pause target"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
692 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
693 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
694 |
// Even the minimum length doesn't fit into the pause time |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
695 |
// target, return it as the result nevertheless. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
696 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
697 |
return base_min_length + min_young_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
698 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
699 |
|
2009 | 700 |
double G1CollectorPolicy::predict_survivor_regions_evac_time() { |
701 |
double survivor_regions_evac_time = 0.0; |
|
702 |
for (HeapRegion * r = _recorded_survivor_head; |
|
703 |
r != NULL && r != _recorded_survivor_tail->get_next_young_region(); |
|
704 |
r = r->get_next_young_region()) { |
|
13482 | 705 |
survivor_regions_evac_time += predict_region_elapsed_time_ms(r, gcs_are_young()); |
2009 | 706 |
} |
707 |
return survivor_regions_evac_time; |
|
708 |
} |
|
709 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
710 |
void G1CollectorPolicy::revise_young_list_target_length_if_necessary() { |
1374 | 711 |
guarantee( adaptive_young_list_length(), "should not call this otherwise" ); |
712 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
713 |
size_t rs_lengths = _g1->young_list()->sampled_rs_lengths(); |
1374 | 714 |
if (rs_lengths > _rs_lengths_prediction) { |
715 |
// add 10% to avoid having to recalculate often |
|
716 |
size_t rs_lengths_prediction = rs_lengths * 1100 / 1000; |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
717 |
update_young_list_target_length(rs_lengths_prediction); |
1374 | 718 |
} |
719 |
} |
|
720 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
721 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
722 |
|
1374 | 723 |
HeapWord* G1CollectorPolicy::mem_allocate_work(size_t size, |
724 |
bool is_tlab, |
|
725 |
bool* gc_overhead_limit_was_exceeded) { |
|
726 |
guarantee(false, "Not using this policy feature yet."); |
|
727 |
return NULL; |
|
728 |
} |
|
729 |
||
730 |
// This method controls how a collector handles one or more |
|
731 |
// of its generations being fully allocated. |
|
732 |
HeapWord* G1CollectorPolicy::satisfy_failed_allocation(size_t size, |
|
733 |
bool is_tlab) { |
|
734 |
guarantee(false, "Not using this policy feature yet."); |
|
735 |
return NULL; |
|
736 |
} |
|
737 |
||
738 |
||
739 |
#ifndef PRODUCT |
|
740 |
bool G1CollectorPolicy::verify_young_ages() { |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
741 |
HeapRegion* head = _g1->young_list()->first_region(); |
1374 | 742 |
return |
743 |
verify_young_ages(head, _short_lived_surv_rate_group); |
|
744 |
// also call verify_young_ages on any additional surv rate groups |
|
745 |
} |
|
746 |
||
747 |
bool |
|
748 |
G1CollectorPolicy::verify_young_ages(HeapRegion* head, |
|
749 |
SurvRateGroup *surv_rate_group) { |
|
750 |
guarantee( surv_rate_group != NULL, "pre-condition" ); |
|
751 |
||
752 |
const char* name = surv_rate_group->name(); |
|
753 |
bool ret = true; |
|
754 |
int prev_age = -1; |
|
755 |
||
756 |
for (HeapRegion* curr = head; |
|
757 |
curr != NULL; |
|
758 |
curr = curr->get_next_young_region()) { |
|
759 |
SurvRateGroup* group = curr->surv_rate_group(); |
|
760 |
if (group == NULL && !curr->is_survivor()) { |
|
761 |
gclog_or_tty->print_cr("## %s: encountered NULL surv_rate_group", name); |
|
762 |
ret = false; |
|
763 |
} |
|
764 |
||
765 |
if (surv_rate_group == group) { |
|
766 |
int age = curr->age_in_surv_rate_group(); |
|
767 |
||
768 |
if (age < 0) { |
|
769 |
gclog_or_tty->print_cr("## %s: encountered negative age", name); |
|
770 |
ret = false; |
|
771 |
} |
|
772 |
||
773 |
if (age <= prev_age) { |
|
774 |
gclog_or_tty->print_cr("## %s: region ages are not strictly increasing " |
|
775 |
"(%d, %d)", name, age, prev_age); |
|
776 |
ret = false; |
|
777 |
} |
|
778 |
prev_age = age; |
|
779 |
} |
|
780 |
} |
|
781 |
||
782 |
return ret; |
|
783 |
} |
|
784 |
#endif // PRODUCT |
|
785 |
||
786 |
void G1CollectorPolicy::record_full_collection_start() { |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
787 |
_full_collection_start_sec = os::elapsedTime(); |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
788 |
record_heap_size_info_at_start(true /* full */); |
1374 | 789 |
// Release the future to-space so that it is available for compaction into. |
790 |
_g1->set_full_collection(); |
|
791 |
} |
|
792 |
||
793 |
void G1CollectorPolicy::record_full_collection_end() { |
|
794 |
// Consider this like a collection pause for the purposes of allocation |
|
795 |
// since last pause. |
|
796 |
double end_sec = os::elapsedTime(); |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
797 |
double full_gc_time_sec = end_sec - _full_collection_start_sec; |
1374 | 798 |
double full_gc_time_ms = full_gc_time_sec * 1000.0; |
799 |
||
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
800 |
_trace_old_gen_time_data.record_full_collection(full_gc_time_ms); |
1374 | 801 |
|
2121
0b899b36d991
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
2011
diff
changeset
|
802 |
update_recent_gc_times(end_sec, full_gc_time_ms); |
1374 | 803 |
|
804 |
_g1->clear_full_collection(); |
|
805 |
||
11249 | 806 |
// "Nuke" the heuristics that control the young/mixed GC |
807 |
// transitions and make sure we start with young GCs after the Full GC. |
|
808 |
set_gcs_are_young(true); |
|
809 |
_last_young_gc = false; |
|
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
810 |
clear_initiate_conc_mark_if_possible(); |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
811 |
clear_during_initial_mark_pause(); |
1374 | 812 |
_in_marking_window = false; |
813 |
_in_marking_window_im = false; |
|
814 |
||
815 |
_short_lived_surv_rate_group->start_adding_regions(); |
|
816 |
// also call this on any additional surv rate groups |
|
817 |
||
2009 | 818 |
record_survivor_regions(0, NULL, NULL); |
819 |
||
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
820 |
_free_regions_at_end_of_collection = _g1->num_free_regions(); |
2009 | 821 |
// Reset survivors SurvRateGroup. |
822 |
_survivor_surv_rate_group->reset(); |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
823 |
update_young_list_target_length(); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
824 |
_collectionSetChooser->clear(); |
7398 | 825 |
} |
1374 | 826 |
|
827 |
void G1CollectorPolicy::record_stop_world_start() { |
|
828 |
_stop_world_start = os::elapsedTime(); |
|
829 |
} |
|
830 |
||
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
831 |
void G1CollectorPolicy::record_collection_pause_start(double start_time_sec) { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11581
diff
changeset
|
832 |
// We only need to do this here as the policy will only be applied |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11581
diff
changeset
|
833 |
// to the GC we're about to start. so, no point is calculating this |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11581
diff
changeset
|
834 |
// every time we calculate / recalculate the target young length. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11581
diff
changeset
|
835 |
update_survivors_policy(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
836 |
|
7398 | 837 |
assert(_g1->used() == _g1->recalculate_used(), |
838 |
err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, |
|
839 |
_g1->used(), _g1->recalculate_used())); |
|
1374 | 840 |
|
841 |
double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
842 |
_trace_young_gen_time_data.record_start_collection(s_w_t_ms); |
1374 | 843 |
_stop_world_start = 0.0; |
844 |
||
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
845 |
record_heap_size_info_at_start(false /* full */); |
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
846 |
|
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
847 |
phase_times()->record_cur_collection_start_sec(start_time_sec); |
1374 | 848 |
_pending_cards = _g1->pending_card_num(); |
849 |
||
13482 | 850 |
_collection_set_bytes_used_before = 0; |
10243
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
851 |
_bytes_copied_during_gc = 0; |
1374 | 852 |
|
11249 | 853 |
_last_gc_was_young = false; |
1374 | 854 |
|
855 |
// do that for any other surv rate groups |
|
856 |
_short_lived_surv_rate_group->stop_adding_regions(); |
|
5033 | 857 |
_survivors_age_table.clear(); |
2009 | 858 |
|
1374 | 859 |
assert( verify_young_ages(), "region age verification" ); |
860 |
} |
|
861 |
||
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
862 |
void G1CollectorPolicy::record_concurrent_mark_init_end(double |
1374 | 863 |
mark_init_elapsed_time_ms) { |
864 |
_during_marking = true; |
|
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
865 |
assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now"); |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
866 |
clear_during_initial_mark_pause(); |
1374 | 867 |
_cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; |
868 |
} |
|
869 |
||
870 |
void G1CollectorPolicy::record_concurrent_mark_remark_start() { |
|
871 |
_mark_remark_start_sec = os::elapsedTime(); |
|
872 |
_during_marking = false; |
|
873 |
} |
|
874 |
||
875 |
void G1CollectorPolicy::record_concurrent_mark_remark_end() { |
|
876 |
double end_time_sec = os::elapsedTime(); |
|
877 |
double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; |
|
878 |
_concurrent_mark_remark_times_ms->add(elapsed_time_ms); |
|
879 |
_cur_mark_stop_world_time_ms += elapsed_time_ms; |
|
880 |
_prev_collection_pause_end_ms += elapsed_time_ms; |
|
881 |
||
882 |
_mmu_tracker->add_pause(_mark_remark_start_sec, end_time_sec, true); |
|
883 |
} |
|
884 |
||
885 |
void G1CollectorPolicy::record_concurrent_mark_cleanup_start() { |
|
886 |
_mark_cleanup_start_sec = os::elapsedTime(); |
|
887 |
} |
|
888 |
||
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
889 |
void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { |
11249 | 890 |
_last_young_gc = true; |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
891 |
_in_marking_window = false; |
1374 | 892 |
} |
893 |
||
894 |
void G1CollectorPolicy::record_concurrent_pause() { |
|
895 |
if (_stop_world_start > 0.0) { |
|
896 |
double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0; |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
897 |
_trace_young_gen_time_data.record_yield_time(yield_ms); |
1374 | 898 |
} |
899 |
} |
|
900 |
||
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
901 |
bool G1CollectorPolicy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) { |
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
902 |
if (_g1->concurrent_mark()->cmThread()->during_cycle()) { |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
903 |
return false; |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
904 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
905 |
|
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
906 |
size_t marking_initiating_used_threshold = |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
907 |
(_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
908 |
size_t cur_used_bytes = _g1->non_young_capacity_bytes(); |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
909 |
size_t alloc_byte_size = alloc_word_size * HeapWordSize; |
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
910 |
|
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
911 |
if ((cur_used_bytes + alloc_byte_size) > marking_initiating_used_threshold) { |
18738
a3e1d8a4d53f
8020155: PSR:PERF G1 not collecting old regions when humongous allocations interfer
brutisso
parents:
18025
diff
changeset
|
912 |
if (gcs_are_young() && !_last_young_gc) { |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
913 |
ergo_verbose5(ErgoConcCycles, |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
914 |
"request concurrent cycle initiation", |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
915 |
ergo_format_reason("occupancy higher than threshold") |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
916 |
ergo_format_byte("occupancy") |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
917 |
ergo_format_byte("allocation request") |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
918 |
ergo_format_byte_perc("threshold") |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
919 |
ergo_format_str("source"), |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
920 |
cur_used_bytes, |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
921 |
alloc_byte_size, |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
922 |
marking_initiating_used_threshold, |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
923 |
(double) InitiatingHeapOccupancyPercent, |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
924 |
source); |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
925 |
return true; |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
926 |
} else { |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
927 |
ergo_verbose5(ErgoConcCycles, |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
928 |
"do not request concurrent cycle initiation", |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
929 |
ergo_format_reason("still doing mixed collections") |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
930 |
ergo_format_byte("occupancy") |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
931 |
ergo_format_byte("allocation request") |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
932 |
ergo_format_byte_perc("threshold") |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
933 |
ergo_format_str("source"), |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
934 |
cur_used_bytes, |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
935 |
alloc_byte_size, |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
936 |
marking_initiating_used_threshold, |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
937 |
(double) InitiatingHeapOccupancyPercent, |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
938 |
source); |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
939 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
940 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
941 |
|
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
942 |
return false; |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
943 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
944 |
|
1374 | 945 |
// Anything below that is considered to be zero |
946 |
#define MIN_TIMER_GRANULARITY 0.0000001 |
|
947 |
||
18025 | 948 |
void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, EvacuationInfo& evacuation_info) { |
1374 | 949 |
double end_time_sec = os::elapsedTime(); |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
950 |
assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(), |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
951 |
"otherwise, the subtraction below does not make sense"); |
1374 | 952 |
size_t rs_size = |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
953 |
_cur_collection_pause_used_regions_at_start - cset_region_length(); |
1374 | 954 |
size_t cur_used_bytes = _g1->used(); |
955 |
assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); |
|
956 |
bool last_pause_included_initial_mark = false; |
|
6249 | 957 |
bool update_stats = !_g1->evacuation_failed(); |
1374 | 958 |
|
959 |
#ifndef PRODUCT |
|
960 |
if (G1YoungSurvRateVerbose) { |
|
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
961 |
gclog_or_tty->cr(); |
1374 | 962 |
_short_lived_surv_rate_group->print(); |
963 |
// do that for any other surv rate groups too |
|
964 |
} |
|
965 |
#endif // PRODUCT |
|
966 |
||
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
967 |
last_pause_included_initial_mark = during_initial_mark_pause(); |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
968 |
if (last_pause_included_initial_mark) { |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
969 |
record_concurrent_mark_init_end(0.0); |
18738
a3e1d8a4d53f
8020155: PSR:PERF G1 not collecting old regions when humongous allocations interfer
brutisso
parents:
18025
diff
changeset
|
970 |
} else if (need_to_start_conc_mark("end of GC")) { |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
971 |
// Note: this might have already been set, if during the last |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
972 |
// pause we decided to start a cycle but at the beginning of |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
973 |
// this pause we decided to postpone it. That's OK. |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
974 |
set_initiate_conc_mark_if_possible(); |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
975 |
} |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
976 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
977 |
_mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0, |
1374 | 978 |
end_time_sec, false); |
979 |
||
18025 | 980 |
evacuation_info.set_collectionset_used_before(_collection_set_bytes_used_before); |
981 |
evacuation_info.set_bytes_copied(_bytes_copied_during_gc); |
|
982 |
||
2121
0b899b36d991
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
2011
diff
changeset
|
983 |
if (update_stats) { |
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
984 |
_trace_young_gen_time_data.record_end_collection(pause_time_ms, phase_times()); |
1374 | 985 |
// this is where we update the allocation rate of the application |
986 |
double app_time_ms = |
|
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
987 |
(phase_times()->cur_collection_start_sec() * 1000.0 - _prev_collection_pause_end_ms); |
1374 | 988 |
if (app_time_ms < MIN_TIMER_GRANULARITY) { |
989 |
// This usually happens due to the timer not having the required |
|
990 |
// granularity. Some Linuxes are the usual culprits. |
|
991 |
// We'll just set it to something (arbitrarily) small. |
|
992 |
app_time_ms = 1.0; |
|
993 |
} |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
994 |
// We maintain the invariant that all objects allocated by mutator |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
995 |
// threads will be allocated out of eden regions. So, we can use |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
996 |
// the eden region number allocated since the previous GC to |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
997 |
// calculate the application's allocate rate. The only exception |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
998 |
// to that is humongous objects that are allocated separately. But |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
999 |
// given that humongous object allocations do not really affect |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1000 |
// either the pause's duration nor when the next pause will take |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1001 |
// place we can safely ignore them here. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1002 |
uint regions_allocated = eden_cset_region_length(); |
1374 | 1003 |
double alloc_rate_ms = (double) regions_allocated / app_time_ms; |
1004 |
_alloc_rate_ms_seq->add(alloc_rate_ms); |
|
1005 |
||
1006 |
double interval_ms = |
|
1007 |
(end_time_sec - _recent_prev_end_times_for_all_gcs_sec->oldest()) * 1000.0; |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
1008 |
update_recent_gc_times(end_time_sec, pause_time_ms); |
1374 | 1009 |
_recent_avg_pause_time_ratio = _recent_gc_times_ms->sum()/interval_ms; |
4456
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1010 |
if (recent_avg_pause_time_ratio() < 0.0 || |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1011 |
(recent_avg_pause_time_ratio() - 1.0 > 0.0)) { |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1012 |
#ifndef PRODUCT |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1013 |
// Dump info to allow post-facto debugging |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1014 |
gclog_or_tty->print_cr("recent_avg_pause_time_ratio() out of bounds"); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1015 |
gclog_or_tty->print_cr("-------------------------------------------"); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1016 |
gclog_or_tty->print_cr("Recent GC Times (ms):"); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1017 |
_recent_gc_times_ms->dump(); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1018 |
gclog_or_tty->print_cr("(End Time=%3.3f) Recent GC End Times (s):", end_time_sec); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1019 |
_recent_prev_end_times_for_all_gcs_sec->dump(); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1020 |
gclog_or_tty->print_cr("GC = %3.3f, Interval = %3.3f, Ratio = %3.3f", |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1021 |
_recent_gc_times_ms->sum(), interval_ms, recent_avg_pause_time_ratio()); |
4457
f05d2dc1c332
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
4456
diff
changeset
|
1022 |
// In debug mode, terminate the JVM if the user wants to debug at this point. |
f05d2dc1c332
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
4456
diff
changeset
|
1023 |
assert(!G1FailOnFPError, "Debugging data for CR 6898948 has been dumped above"); |
f05d2dc1c332
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
4456
diff
changeset
|
1024 |
#endif // !PRODUCT |
f05d2dc1c332
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
4456
diff
changeset
|
1025 |
// Clip ratio between 0.0 and 1.0, and continue. This will be fixed in |
f05d2dc1c332
6902701: G1: protect debugging code related to 6898948 with a debug flag
ysr
parents:
4456
diff
changeset
|
1026 |
// CR 6902692 by redoing the manner in which the ratio is incrementally computed. |
4456
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1027 |
if (_recent_avg_pause_time_ratio < 0.0) { |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1028 |
_recent_avg_pause_time_ratio = 0.0; |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1029 |
} else { |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1030 |
assert(_recent_avg_pause_time_ratio - 1.0 > 0.0, "Ctl-point invariant"); |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1031 |
_recent_avg_pause_time_ratio = 1.0; |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1032 |
} |
fa02c2ef7a70
6898948: G1: forensic instrumentation for out-of-bounds recent_avg_pause_time_ratio()
ysr
parents:
4098
diff
changeset
|
1033 |
} |
1374 | 1034 |
} |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1035 |
|
1374 | 1036 |
bool new_in_marking_window = _in_marking_window; |
1037 |
bool new_in_marking_window_im = false; |
|
25727
7afb6523f5ab
8049051: Use of during_initial_mark_pause() in G1CollectorPolicy::record_collection_pause_end() prevents use of seperate object copy time prediction during marking
tschatzl
parents:
24941
diff
changeset
|
1038 |
if (last_pause_included_initial_mark) { |
1374 | 1039 |
new_in_marking_window = true; |
1040 |
new_in_marking_window_im = true; |
|
1041 |
} |
|
1042 |
||
11249 | 1043 |
if (_last_young_gc) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1044 |
// This is supposed to to be the "last young GC" before we start |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1045 |
// doing mixed GCs. Here we decide whether to start mixed GCs or not. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1046 |
|
10673
8235e1a1b41b
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
10670
diff
changeset
|
1047 |
if (!last_pause_included_initial_mark) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1048 |
if (next_gc_should_be_mixed("start mixed GCs", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1049 |
"do not start mixed GCs")) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1050 |
set_gcs_are_young(false); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1051 |
} |
10673
8235e1a1b41b
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
10670
diff
changeset
|
1052 |
} else { |
11249 | 1053 |
ergo_verbose0(ErgoMixedGCs, |
1054 |
"do not start mixed GCs", |
|
10673
8235e1a1b41b
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
10670
diff
changeset
|
1055 |
ergo_format_reason("concurrent cycle is about to start")); |
8235e1a1b41b
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
10670
diff
changeset
|
1056 |
} |
11249 | 1057 |
_last_young_gc = false; |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1058 |
} |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1059 |
|
11249 | 1060 |
if (!_last_gc_was_young) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1061 |
// This is a mixed GC. Here we decide whether to continue doing |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1062 |
// mixed GCs or not. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1063 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1064 |
if (!next_gc_should_be_mixed("continue mixed GCs", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1065 |
"do not continue mixed GCs")) { |
11249 | 1066 |
set_gcs_are_young(true); |
1374 | 1067 |
} |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1068 |
} |
11249 | 1069 |
|
1374 | 1070 |
_short_lived_surv_rate_group->start_adding_regions(); |
22551 | 1071 |
// Do that for any other surv rate groups |
1374 | 1072 |
|
2344 | 1073 |
if (update_stats) { |
1374 | 1074 |
double cost_per_card_ms = 0.0; |
1075 |
if (_pending_cards > 0) { |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1076 |
cost_per_card_ms = phase_times()->average_time_ms(G1GCPhaseTimes::UpdateRS) / (double) _pending_cards; |
1374 | 1077 |
_cost_per_card_ms_seq->add(cost_per_card_ms); |
1078 |
} |
|
1079 |
||
1080 |
size_t cards_scanned = _g1->cards_scanned(); |
|
1081 |
||
1082 |
double cost_per_entry_ms = 0.0; |
|
1083 |
if (cards_scanned > 10) { |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1084 |
cost_per_entry_ms = phase_times()->average_time_ms(G1GCPhaseTimes::ScanRS) / (double) cards_scanned; |
11249 | 1085 |
if (_last_gc_was_young) { |
1374 | 1086 |
_cost_per_entry_ms_seq->add(cost_per_entry_ms); |
11249 | 1087 |
} else { |
1088 |
_mixed_cost_per_entry_ms_seq->add(cost_per_entry_ms); |
|
1089 |
} |
|
1374 | 1090 |
} |
1091 |
||
1092 |
if (_max_rs_lengths > 0) { |
|
1093 |
double cards_per_entry_ratio = |
|
1094 |
(double) cards_scanned / (double) _max_rs_lengths; |
|
11249 | 1095 |
if (_last_gc_was_young) { |
1096 |
_young_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); |
|
1097 |
} else { |
|
1098 |
_mixed_cards_per_entry_ratio_seq->add(cards_per_entry_ratio); |
|
1099 |
} |
|
1374 | 1100 |
} |
1101 |
||
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1102 |
// This is defensive. For a while _max_rs_lengths could get |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1103 |
// smaller than _recorded_rs_lengths which was causing |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1104 |
// rs_length_diff to get very large and mess up the RSet length |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1105 |
// predictions. The reason was unsafe concurrent updates to the |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1106 |
// _inc_cset_recorded_rs_lengths field which the code below guards |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1107 |
// against (see CR 7118202). This bug has now been fixed (see CR |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1108 |
// 7119027). However, I'm still worried that |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1109 |
// _inc_cset_recorded_rs_lengths might still end up somewhat |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1110 |
// inaccurate. The concurrent refinement thread calculates an |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1111 |
// RSet's length concurrently with other CR threads updating it |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1112 |
// which might cause it to calculate the length incorrectly (if, |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1113 |
// say, it's in mid-coarsening). So I'll leave in the defensive |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1114 |
// conditional below just in case. |
11206
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
1115 |
size_t rs_length_diff = 0; |
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
1116 |
if (_max_rs_lengths > _recorded_rs_lengths) { |
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
1117 |
rs_length_diff = _max_rs_lengths - _recorded_rs_lengths; |
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
1118 |
} |
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
1119 |
_rs_length_diff_seq->add((double) rs_length_diff); |
1374 | 1120 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1121 |
size_t freed_bytes = _heap_used_bytes_before_gc - cur_used_bytes; |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1122 |
size_t copied_bytes = _collection_set_bytes_used_before - freed_bytes; |
1374 | 1123 |
double cost_per_byte_ms = 0.0; |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1124 |
|
1374 | 1125 |
if (copied_bytes > 0) { |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1126 |
cost_per_byte_ms = phase_times()->average_time_ms(G1GCPhaseTimes::ObjCopy) / (double) copied_bytes; |
11249 | 1127 |
if (_in_marking_window) { |
1374 | 1128 |
_cost_per_byte_ms_during_cm_seq->add(cost_per_byte_ms); |
11249 | 1129 |
} else { |
1374 | 1130 |
_cost_per_byte_ms_seq->add(cost_per_byte_ms); |
11249 | 1131 |
} |
1374 | 1132 |
} |
1133 |
||
1134 |
double all_other_time_ms = pause_time_ms - |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1135 |
(phase_times()->average_time_ms(G1GCPhaseTimes::UpdateRS) + phase_times()->average_time_ms(G1GCPhaseTimes::ScanRS) + |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1136 |
phase_times()->average_time_ms(G1GCPhaseTimes::ObjCopy) + phase_times()->average_time_ms(G1GCPhaseTimes::Termination)); |
1374 | 1137 |
|
1138 |
double young_other_time_ms = 0.0; |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1139 |
if (young_cset_region_length() > 0) { |
1374 | 1140 |
young_other_time_ms = |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1141 |
phase_times()->young_cset_choice_time_ms() + |
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1142 |
phase_times()->young_free_cset_time_ms(); |
1374 | 1143 |
_young_other_cost_per_region_ms_seq->add(young_other_time_ms / |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1144 |
(double) young_cset_region_length()); |
1374 | 1145 |
} |
1146 |
double non_young_other_time_ms = 0.0; |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1147 |
if (old_cset_region_length() > 0) { |
1374 | 1148 |
non_young_other_time_ms = |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1149 |
phase_times()->non_young_cset_choice_time_ms() + |
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1150 |
phase_times()->non_young_free_cset_time_ms(); |
1374 | 1151 |
|
1152 |
_non_young_other_cost_per_region_ms_seq->add(non_young_other_time_ms / |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1153 |
(double) old_cset_region_length()); |
1374 | 1154 |
} |
1155 |
||
1156 |
double constant_other_time_ms = all_other_time_ms - |
|
1157 |
(young_other_time_ms + non_young_other_time_ms); |
|
1158 |
_constant_other_time_ms_seq->add(constant_other_time_ms); |
|
1159 |
||
1160 |
double survival_ratio = 0.0; |
|
13482 | 1161 |
if (_collection_set_bytes_used_before > 0) { |
10243
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
1162 |
survival_ratio = (double) _bytes_copied_during_gc / |
13482 | 1163 |
(double) _collection_set_bytes_used_before; |
1374 | 1164 |
} |
1165 |
||
1166 |
_pending_cards_seq->add((double) _pending_cards); |
|
1167 |
_rs_lengths_seq->add((double) _max_rs_lengths); |
|
1168 |
} |
|
1169 |
||
1170 |
_in_marking_window = new_in_marking_window; |
|
1171 |
_in_marking_window_im = new_in_marking_window_im; |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
1172 |
_free_regions_at_end_of_collection = _g1->num_free_regions(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1173 |
update_young_list_target_length(); |
1374 | 1174 |
|
4481 | 1175 |
// Note that _mmu_tracker->max_gc_time() returns the time in seconds. |
5033 | 1176 |
double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1177 |
adjust_concurrent_refinement(phase_times()->average_time_ms(G1GCPhaseTimes::UpdateRS), |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
1178 |
phase_times()->sum_thread_work_items(G1GCPhaseTimes::UpdateRS), update_rs_time_goal_ms); |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1179 |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1180 |
_collectionSetChooser->verify(); |
1374 | 1181 |
} |
1182 |
||
12625 | 1183 |
#define EXT_SIZE_FORMAT "%.1f%s" |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1184 |
#define EXT_SIZE_PARAMS(bytes) \ |
12625 | 1185 |
byte_size_in_proper_unit((double)(bytes)), \ |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1186 |
proper_unit_for_byte_size((bytes)) |
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1187 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1188 |
void G1CollectorPolicy::record_heap_size_info_at_start(bool full) { |
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
1189 |
YoungList* young_list = _g1->young_list(); |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1190 |
_eden_used_bytes_before_gc = young_list->eden_used_bytes(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1191 |
_survivor_used_bytes_before_gc = young_list->survivor_used_bytes(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1192 |
_heap_capacity_bytes_before_gc = _g1->capacity(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1193 |
_heap_used_bytes_before_gc = _g1->used(); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
1194 |
_cur_collection_pause_used_regions_at_start = _g1->num_used_regions(); |
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
1195 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1196 |
_eden_capacity_bytes_before_gc = |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1197 |
(_young_list_target_length * HeapRegion::GrainBytes) - _survivor_used_bytes_before_gc; |
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
1198 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1199 |
if (full) { |
23854
50f7f89b34e0
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
22551
diff
changeset
|
1200 |
_metaspace_used_bytes_before_gc = MetaspaceAux::used_bytes(); |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1201 |
} |
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
1202 |
} |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
1203 |
|
29795
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1204 |
void G1CollectorPolicy::print_heap_transition(size_t bytes_before) { |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1205 |
size_t bytes_after = _g1->used(); |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1206 |
size_t capacity = _g1->capacity(); |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1207 |
|
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1208 |
gclog_or_tty->print(" " SIZE_FORMAT "%s->" SIZE_FORMAT "%s(" SIZE_FORMAT "%s)", |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1209 |
byte_size_in_proper_unit(bytes_before), |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1210 |
proper_unit_for_byte_size(bytes_before), |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1211 |
byte_size_in_proper_unit(bytes_after), |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1212 |
proper_unit_for_byte_size(bytes_after), |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1213 |
byte_size_in_proper_unit(capacity), |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1214 |
proper_unit_for_byte_size(capacity)); |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1215 |
} |
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1216 |
|
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1217 |
void G1CollectorPolicy::print_heap_transition() { |
29795
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
29697
diff
changeset
|
1218 |
print_heap_transition(_heap_used_bytes_before_gc); |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1219 |
} |
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1220 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1221 |
void G1CollectorPolicy::print_detailed_heap_transition(bool full) { |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1222 |
YoungList* young_list = _g1->young_list(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1223 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1224 |
size_t eden_used_bytes_after_gc = young_list->eden_used_bytes(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1225 |
size_t survivor_used_bytes_after_gc = young_list->survivor_used_bytes(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1226 |
size_t heap_used_bytes_after_gc = _g1->used(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1227 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1228 |
size_t heap_capacity_bytes_after_gc = _g1->capacity(); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1229 |
size_t eden_capacity_bytes_after_gc = |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1230 |
(_young_list_target_length * HeapRegion::GrainBytes) - survivor_used_bytes_after_gc; |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1231 |
|
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1232 |
gclog_or_tty->print( |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1233 |
" [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") " |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1234 |
"Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1235 |
"Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1236 |
EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1237 |
EXT_SIZE_PARAMS(_eden_used_bytes_before_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1238 |
EXT_SIZE_PARAMS(_eden_capacity_bytes_before_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1239 |
EXT_SIZE_PARAMS(eden_used_bytes_after_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1240 |
EXT_SIZE_PARAMS(eden_capacity_bytes_after_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1241 |
EXT_SIZE_PARAMS(_survivor_used_bytes_before_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1242 |
EXT_SIZE_PARAMS(survivor_used_bytes_after_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1243 |
EXT_SIZE_PARAMS(_heap_used_bytes_before_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1244 |
EXT_SIZE_PARAMS(_heap_capacity_bytes_before_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1245 |
EXT_SIZE_PARAMS(heap_used_bytes_after_gc), |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1246 |
EXT_SIZE_PARAMS(heap_capacity_bytes_after_gc)); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1247 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1248 |
if (full) { |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1249 |
MetaspaceAux::print_metaspace_change(_metaspace_used_bytes_before_gc); |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1250 |
} |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1251 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
1252 |
gclog_or_tty->cr(); |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1253 |
} |
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
1254 |
|
4481 | 1255 |
void G1CollectorPolicy::adjust_concurrent_refinement(double update_rs_time, |
1256 |
double update_rs_processed_buffers, |
|
1257 |
double goal_ms) { |
|
1258 |
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
|
1259 |
ConcurrentG1Refine *cg1r = G1CollectedHeap::heap()->concurrent_g1_refine(); |
|
1260 |
||
5033 | 1261 |
if (G1UseAdaptiveConcRefinement) { |
4481 | 1262 |
const int k_gy = 3, k_gr = 6; |
1263 |
const double inc_k = 1.1, dec_k = 0.9; |
|
1264 |
||
1265 |
int g = cg1r->green_zone(); |
|
1266 |
if (update_rs_time > goal_ms) { |
|
1267 |
g = (int)(g * dec_k); // Can become 0, that's OK. That would mean a mutator-only processing. |
|
1268 |
} else { |
|
1269 |
if (update_rs_time < goal_ms && update_rs_processed_buffers > g) { |
|
1270 |
g = (int)MAX2(g * inc_k, g + 1.0); |
|
1271 |
} |
|
1272 |
} |
|
1273 |
// Change the refinement threads params |
|
1274 |
cg1r->set_green_zone(g); |
|
1275 |
cg1r->set_yellow_zone(g * k_gy); |
|
1276 |
cg1r->set_red_zone(g * k_gr); |
|
1277 |
cg1r->reinitialize_threads(); |
|
1278 |
||
1279 |
int processing_threshold_delta = MAX2((int)(cg1r->green_zone() * sigma()), 1); |
|
1280 |
int processing_threshold = MIN2(cg1r->green_zone() + processing_threshold_delta, |
|
1281 |
cg1r->yellow_zone()); |
|
1282 |
// Change the barrier params |
|
1283 |
dcqs.set_process_completed_threshold(processing_threshold); |
|
1284 |
dcqs.set_max_completed_queue(cg1r->red_zone()); |
|
1285 |
} |
|
1286 |
||
1287 |
int curr_queue_size = dcqs.completed_buffers_num(); |
|
1288 |
if (curr_queue_size >= cg1r->yellow_zone()) { |
|
1289 |
dcqs.set_completed_queue_padding(curr_queue_size); |
|
1290 |
} else { |
|
1291 |
dcqs.set_completed_queue_padding(0); |
|
1292 |
} |
|
1293 |
dcqs.notify_if_necessary(); |
|
1294 |
} |
|
1295 |
||
1374 | 1296 |
double |
1297 |
G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards, |
|
1298 |
size_t scanned_cards) { |
|
1299 |
return |
|
1300 |
predict_rs_update_time_ms(pending_cards) + |
|
1301 |
predict_rs_scan_time_ms(scanned_cards) + |
|
1302 |
predict_constant_other_time_ms(); |
|
1303 |
} |
|
1304 |
||
1305 |
double |
|
13482 | 1306 |
G1CollectorPolicy::predict_base_elapsed_time_ms(size_t pending_cards) { |
1307 |
size_t rs_length = predict_rs_length_diff(); |
|
1374 | 1308 |
size_t card_num; |
11249 | 1309 |
if (gcs_are_young()) { |
1374 | 1310 |
card_num = predict_young_card_num(rs_length); |
11249 | 1311 |
} else { |
1374 | 1312 |
card_num = predict_non_young_card_num(rs_length); |
11249 | 1313 |
} |
13482 | 1314 |
return predict_base_elapsed_time_ms(pending_cards, card_num); |
1374 | 1315 |
} |
1316 |
||
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1317 |
size_t G1CollectorPolicy::predict_bytes_to_copy(HeapRegion* hr) { |
1374 | 1318 |
size_t bytes_to_copy; |
1319 |
if (hr->is_marked()) |
|
1320 |
bytes_to_copy = hr->max_live_bytes(); |
|
1321 |
else { |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1322 |
assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant"); |
1374 | 1323 |
int age = hr->age_in_surv_rate_group(); |
2009 | 1324 |
double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); |
1374 | 1325 |
bytes_to_copy = (size_t) ((double) hr->used() * yg_surv_rate); |
1326 |
} |
|
1327 |
return bytes_to_copy; |
|
1328 |
} |
|
1329 |
||
13482 | 1330 |
double |
1331 |
G1CollectorPolicy::predict_region_elapsed_time_ms(HeapRegion* hr, |
|
1332 |
bool for_young_gc) { |
|
1333 |
size_t rs_length = hr->rem_set()->occupied(); |
|
1334 |
size_t card_num; |
|
1335 |
||
1336 |
// Predicting the number of cards is based on which type of GC |
|
1337 |
// we're predicting for. |
|
1338 |
if (for_young_gc) { |
|
1339 |
card_num = predict_young_card_num(rs_length); |
|
1340 |
} else { |
|
1341 |
card_num = predict_non_young_card_num(rs_length); |
|
1342 |
} |
|
1343 |
size_t bytes_to_copy = predict_bytes_to_copy(hr); |
|
1344 |
||
1345 |
double region_elapsed_time_ms = |
|
1346 |
predict_rs_scan_time_ms(card_num) + |
|
1347 |
predict_object_copy_time_ms(bytes_to_copy); |
|
1348 |
||
1349 |
// The prediction of the "other" time for this region is based |
|
1350 |
// upon the region type and NOT the GC type. |
|
1351 |
if (hr->is_young()) { |
|
1352 |
region_elapsed_time_ms += predict_young_other_time_ms(1); |
|
1353 |
} else { |
|
1354 |
region_elapsed_time_ms += predict_non_young_other_time_ms(1); |
|
1355 |
} |
|
1356 |
return region_elapsed_time_ms; |
|
1357 |
} |
|
1358 |
||
1374 | 1359 |
void |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1360 |
G1CollectorPolicy::init_cset_region_lengths(uint eden_cset_region_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1361 |
uint survivor_cset_region_length) { |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1362 |
_eden_cset_region_length = eden_cset_region_length; |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1363 |
_survivor_cset_region_length = survivor_cset_region_length; |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1364 |
_old_cset_region_length = 0; |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1365 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1366 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1367 |
void G1CollectorPolicy::set_recorded_rs_lengths(size_t rs_lengths) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1368 |
_recorded_rs_lengths = rs_lengths; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1369 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1370 |
|
1374 | 1371 |
void G1CollectorPolicy::update_recent_gc_times(double end_time_sec, |
1372 |
double elapsed_ms) { |
|
1373 |
_recent_gc_times_ms->add(elapsed_ms); |
|
1374 |
_recent_prev_end_times_for_all_gcs_sec->add(end_time_sec); |
|
1375 |
_prev_collection_pause_end_ms = end_time_sec * 1000.0; |
|
1376 |
} |
|
1377 |
||
1378 |
size_t G1CollectorPolicy::expansion_amount() { |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1379 |
double recent_gc_overhead = recent_avg_pause_time_ratio() * 100.0; |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1380 |
double threshold = _gc_overhead_perc; |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1381 |
if (recent_gc_overhead > threshold) { |
2741 | 1382 |
// We will double the existing space, or take |
1383 |
// G1ExpandByPercentOfAvailable % of the available expansion |
|
1384 |
// space, whichever is smaller, bounded below by a minimum |
|
1385 |
// expansion (unless that's all that's left.) |
|
1374 | 1386 |
const size_t min_expand_bytes = 1*M; |
8103
65eafe3fb3c7
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
7923
diff
changeset
|
1387 |
size_t reserved_bytes = _g1->max_capacity(); |
1374 | 1388 |
size_t committed_bytes = _g1->capacity(); |
1389 |
size_t uncommitted_bytes = reserved_bytes - committed_bytes; |
|
1390 |
size_t expand_bytes; |
|
1391 |
size_t expand_bytes_via_pct = |
|
2741 | 1392 |
uncommitted_bytes * G1ExpandByPercentOfAvailable / 100; |
1374 | 1393 |
expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes); |
1394 |
expand_bytes = MAX2(expand_bytes, min_expand_bytes); |
|
1395 |
expand_bytes = MIN2(expand_bytes, uncommitted_bytes); |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1396 |
|
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1397 |
ergo_verbose5(ErgoHeapSizing, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1398 |
"attempt heap expansion", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1399 |
ergo_format_reason("recent GC overhead higher than " |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1400 |
"threshold after GC") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1401 |
ergo_format_perc("recent GC overhead") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1402 |
ergo_format_perc("threshold") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1403 |
ergo_format_byte("uncommitted") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1404 |
ergo_format_byte_perc("calculated expansion amount"), |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1405 |
recent_gc_overhead, threshold, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1406 |
uncommitted_bytes, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1407 |
expand_bytes_via_pct, (double) G1ExpandByPercentOfAvailable); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1408 |
|
1374 | 1409 |
return expand_bytes; |
1410 |
} else { |
|
1411 |
return 0; |
|
1412 |
} |
|
1413 |
} |
|
1414 |
||
1415 |
void G1CollectorPolicy::print_tracing_info() const { |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
1416 |
_trace_young_gen_time_data.print(); |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
1417 |
_trace_old_gen_time_data.print(); |
1374 | 1418 |
} |
1419 |
||
1420 |
void G1CollectorPolicy::print_yg_surv_rate_info() const { |
|
1421 |
#ifndef PRODUCT |
|
1422 |
_short_lived_surv_rate_group->print_surv_rate_summary(); |
|
1423 |
// add this call for any other surv rate groups |
|
1424 |
#endif // PRODUCT |
|
1425 |
} |
|
1426 |
||
27892
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1427 |
bool G1CollectorPolicy::is_young_list_full() { |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1428 |
uint young_list_length = _g1->young_list()->length(); |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1429 |
uint young_list_target_length = _young_list_target_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1430 |
return young_list_length >= young_list_target_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1431 |
} |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1432 |
|
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1433 |
bool G1CollectorPolicy::can_expand_young_list() { |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1434 |
uint young_list_length = _g1->young_list()->length(); |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1435 |
uint young_list_max_length = _young_list_max_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1436 |
return young_list_length < young_list_max_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1437 |
} |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
1438 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1439 |
void G1CollectorPolicy::update_max_gc_locker_expansion() { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1440 |
uint expansion_region_num = 0; |
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1441 |
if (GCLockerEdenExpansionPercent > 0) { |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1442 |
double perc = (double) GCLockerEdenExpansionPercent / 100.0; |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1443 |
double expansion_region_num_d = perc * (double) _young_list_target_length; |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1444 |
// We use ceiling so that if expansion_region_num_d is > 0.0 (but |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1445 |
// less than 1.0) we'll get 1. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1446 |
expansion_region_num = (uint) ceil(expansion_region_num_d); |
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1447 |
} else { |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1448 |
assert(expansion_region_num == 0, "sanity"); |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1449 |
} |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1450 |
_young_list_max_length = _young_list_target_length + expansion_region_num; |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1451 |
assert(_young_list_target_length <= _young_list_max_length, "post-condition"); |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1452 |
} |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
1453 |
|
2009 | 1454 |
// Calculates survivor space parameters. |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1455 |
void G1CollectorPolicy::update_survivors_policy() { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1456 |
double max_survivor_regions_d = |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1457 |
(double) _young_list_target_length / (double) SurvivorRatio; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1458 |
// We use ceiling so that if max_survivor_regions_d is > 0.0 (but |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1459 |
// smaller than 1.0) we'll get 1. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1460 |
_max_survivor_regions = (uint) ceil(max_survivor_regions_d); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
1461 |
|
10281
ad7517425333
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
10280
diff
changeset
|
1462 |
_tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( |
30147
af9a41999c6e
8076314: Remove the static instance variable SharedHeap:: _sh
brutisso
parents:
29795
diff
changeset
|
1463 |
HeapRegion::GrainWords * _max_survivor_regions, counters()); |
2009 | 1464 |
} |
1465 |
||
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1466 |
bool G1CollectorPolicy::force_initial_mark_if_outside_cycle( |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1467 |
GCCause::Cause gc_cause) { |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1468 |
bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1469 |
if (!during_cycle) { |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1470 |
ergo_verbose1(ErgoConcCycles, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1471 |
"request concurrent cycle initiation", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1472 |
ergo_format_reason("requested by GC cause") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1473 |
ergo_format_str("GC cause"), |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1474 |
GCCause::to_string(gc_cause)); |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1475 |
set_initiate_conc_mark_if_possible(); |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1476 |
return true; |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1477 |
} else { |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1478 |
ergo_verbose1(ErgoConcCycles, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1479 |
"do not request concurrent cycle initiation", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1480 |
ergo_format_reason("concurrent cycle already in progress") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1481 |
ergo_format_str("GC cause"), |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1482 |
GCCause::to_string(gc_cause)); |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1483 |
return false; |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1484 |
} |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1485 |
} |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1486 |
|
1374 | 1487 |
void |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1488 |
G1CollectorPolicy::decide_on_conc_mark_initiation() { |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1489 |
// We are about to decide on whether this pause will be an |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1490 |
// initial-mark pause. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1491 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1492 |
// First, during_initial_mark_pause() should not be already set. We |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1493 |
// will set it here if we have to. However, it should be cleared by |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1494 |
// the end of the pause (it's only set for the duration of an |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1495 |
// initial-mark pause). |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1496 |
assert(!during_initial_mark_pause(), "pre-condition"); |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1497 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1498 |
if (initiate_conc_mark_if_possible()) { |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1499 |
// We had noticed on a previous pause that the heap occupancy has |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1500 |
// gone over the initiating threshold and we should start a |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1501 |
// concurrent marking cycle. So we might initiate one. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1502 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1503 |
bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1504 |
if (!during_cycle) { |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1505 |
// The concurrent marking thread is not "during a cycle", i.e., |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1506 |
// it has completed the last one. So we can go ahead and |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1507 |
// initiate a new cycle. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1508 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1509 |
set_during_initial_mark_pause(); |
11249 | 1510 |
// We do not allow mixed GCs during marking. |
1511 |
if (!gcs_are_young()) { |
|
1512 |
set_gcs_are_young(true); |
|
1513 |
ergo_verbose0(ErgoMixedGCs, |
|
1514 |
"end mixed GCs", |
|
10673
8235e1a1b41b
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
10670
diff
changeset
|
1515 |
ergo_format_reason("concurrent cycle is about to start")); |
8235e1a1b41b
7086533: G1: assert(!_g1->is_obj_dead(obj)): We should not be preserving dead objs: g1CollectedHeap.cpp:3835
johnc
parents:
10670
diff
changeset
|
1516 |
} |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1517 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1518 |
// And we can now clear initiate_conc_mark_if_possible() as |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1519 |
// we've already acted on it. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1520 |
clear_initiate_conc_mark_if_possible(); |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1521 |
|
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1522 |
ergo_verbose0(ErgoConcCycles, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1523 |
"initiate concurrent cycle", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1524 |
ergo_format_reason("concurrent cycle initiation requested")); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1525 |
} else { |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1526 |
// The concurrent marking thread is still finishing up the |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1527 |
// previous cycle. If we start one right now the two cycles |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1528 |
// overlap. In particular, the concurrent marking thread might |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1529 |
// be in the process of clearing the next marking bitmap (which |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1530 |
// we will use for the next cycle if we start one). Starting a |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1531 |
// cycle now will be bad given that parts of the marking |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1532 |
// information might get cleared by the marking thread. And we |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1533 |
// cannot wait for the marking thread to finish the cycle as it |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1534 |
// periodically yields while clearing the next marking bitmap |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1535 |
// and, if it's in a yield point, it's waiting for us to |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1536 |
// finish. So, at this point we will not start a cycle and we'll |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1537 |
// let the concurrent marking thread complete the last one. |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1538 |
ergo_verbose0(ErgoConcCycles, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1539 |
"do not initiate concurrent cycle", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1540 |
ergo_format_reason("concurrent cycle already in progress")); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1541 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1542 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1543 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1544 |
|
1374 | 1545 |
class ParKnownGarbageHRClosure: public HeapRegionClosure { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1546 |
G1CollectedHeap* _g1h; |
13336
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13288
diff
changeset
|
1547 |
CSetChooserParUpdater _cset_updater; |
1374 | 1548 |
|
1549 |
public: |
|
1550 |
ParKnownGarbageHRClosure(CollectionSetChooser* hrSorted, |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1551 |
uint chunk_size) : |
13336
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13288
diff
changeset
|
1552 |
_g1h(G1CollectedHeap::heap()), |
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13288
diff
changeset
|
1553 |
_cset_updater(hrSorted, true /* parallel */, chunk_size) { } |
1374 | 1554 |
|
1555 |
bool doHeapRegion(HeapRegion* r) { |
|
1556 |
// Do we have any marking information for this region? |
|
1557 |
if (r->is_marked()) { |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1558 |
// We will skip any region that's currently used as an old GC |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1559 |
// alloc region (we should not consider those for collection |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1560 |
// before we fill them up). |
13336
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13288
diff
changeset
|
1561 |
if (_cset_updater.should_add(r) && !_g1h->is_old_gc_alloc_region(r)) { |
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13288
diff
changeset
|
1562 |
_cset_updater.add_region(r); |
1374 | 1563 |
} |
1564 |
} |
|
1565 |
return false; |
|
1566 |
} |
|
1567 |
}; |
|
1568 |
||
1569 |
class ParKnownGarbageTask: public AbstractGangTask { |
|
1570 |
CollectionSetChooser* _hrSorted; |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1571 |
uint _chunk_size; |
1374 | 1572 |
G1CollectedHeap* _g1; |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1573 |
HeapRegionClaimer _hrclaimer; |
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1574 |
|
1374 | 1575 |
public: |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1576 |
ParKnownGarbageTask(CollectionSetChooser* hrSorted, uint chunk_size, uint n_workers) : |
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1577 |
AbstractGangTask("ParKnownGarbageTask"), |
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1578 |
_hrSorted(hrSorted), _chunk_size(chunk_size), |
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1579 |
_g1(G1CollectedHeap::heap()), _hrclaimer(n_workers) {} |
1374 | 1580 |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11395
diff
changeset
|
1581 |
void work(uint worker_id) { |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1582 |
ParKnownGarbageHRClosure parKnownGarbageCl(_hrSorted, _chunk_size); |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26696
diff
changeset
|
1583 |
_g1->heap_region_par_iterate(&parKnownGarbageCl, worker_id, &_hrclaimer); |
1374 | 1584 |
} |
1585 |
}; |
|
1586 |
||
27626
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1587 |
uint G1CollectorPolicy::calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) { |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1588 |
assert(n_workers > 0, "Active gc workers should be greater than 0"); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1589 |
const uint overpartition_factor = 4; |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1590 |
const uint min_chunk_size = MAX2(n_regions / n_workers, 1U); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1591 |
return MAX2(n_regions / (n_workers * overpartition_factor), min_chunk_size); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1592 |
} |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1593 |
|
1374 | 1594 |
void |
27626
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1595 |
G1CollectorPolicy::record_concurrent_mark_cleanup_end(uint n_workers) { |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1596 |
_collectionSetChooser->clear(); |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1597 |
|
27626
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1598 |
uint n_regions = _g1->num_regions(); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1599 |
uint chunk_size = calculate_parallel_work_chunk_size(n_workers, n_regions); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1600 |
_collectionSetChooser->prepare_for_par_region_addition(n_regions, chunk_size); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1601 |
ParKnownGarbageTask par_known_garbage_task(_collectionSetChooser, chunk_size, n_workers); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
27251
diff
changeset
|
1602 |
_g1->workers()->run_task(&par_known_garbage_task); |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1603 |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1604 |
_collectionSetChooser->sort_regions(); |
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1605 |
|
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1606 |
double end_sec = os::elapsedTime(); |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1607 |
double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0; |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1608 |
_concurrent_mark_cleanup_times_ms->add(elapsed_time_ms); |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1609 |
_cur_mark_stop_world_time_ms += elapsed_time_ms; |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1610 |
_prev_collection_pause_end_ms += elapsed_time_ms; |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1611 |
_mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec, true); |
1374 | 1612 |
} |
1613 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1614 |
// Add the heap region at the head of the non-incremental collection set |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1615 |
void G1CollectorPolicy::add_old_region_to_cset(HeapRegion* hr) { |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1616 |
assert(_inc_cset_build_state == Active, "Precondition"); |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1617 |
assert(hr->is_old(), "the region should be old"); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1618 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1619 |
assert(!hr->in_collection_set(), "should not already be in the CSet"); |
29470
e34bbcd36e53
8030646: track collection set membership in one place
ehelin
parents:
29465
diff
changeset
|
1620 |
_g1->register_old_region_with_cset(hr); |
1374 | 1621 |
hr->set_next_in_collection_set(_collection_set); |
1622 |
_collection_set = hr; |
|
1623 |
_collection_set_bytes_used_before += hr->used(); |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1624 |
size_t rs_length = hr->rem_set()->occupied(); |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1625 |
_recorded_rs_lengths += rs_length; |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1626 |
_old_cset_region_length += 1; |
1374 | 1627 |
} |
1628 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1629 |
// Initialize the per-collection-set information |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1630 |
void G1CollectorPolicy::start_incremental_cset_building() { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1631 |
assert(_inc_cset_build_state == Inactive, "Precondition"); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1632 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1633 |
_inc_cset_head = NULL; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1634 |
_inc_cset_tail = NULL; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1635 |
_inc_cset_bytes_used_before = 0; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1636 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1637 |
_inc_cset_max_finger = 0; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1638 |
_inc_cset_recorded_rs_lengths = 0; |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1639 |
_inc_cset_recorded_rs_lengths_diffs = 0; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1640 |
_inc_cset_predicted_elapsed_time_ms = 0.0; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1641 |
_inc_cset_predicted_elapsed_time_ms_diffs = 0.0; |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1642 |
_inc_cset_build_state = Active; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1643 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1644 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1645 |
void G1CollectorPolicy::finalize_incremental_cset_building() { |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1646 |
assert(_inc_cset_build_state == Active, "Precondition"); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1647 |
assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint"); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1648 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1649 |
// The two "main" fields, _inc_cset_recorded_rs_lengths and |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1650 |
// _inc_cset_predicted_elapsed_time_ms, are updated by the thread |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1651 |
// that adds a new region to the CSet. Further updates by the |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1652 |
// concurrent refinement thread that samples the young RSet lengths |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1653 |
// are accumulated in the *_diffs fields. Here we add the diffs to |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1654 |
// the "main" fields. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1655 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1656 |
if (_inc_cset_recorded_rs_lengths_diffs >= 0) { |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1657 |
_inc_cset_recorded_rs_lengths += _inc_cset_recorded_rs_lengths_diffs; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1658 |
} else { |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1659 |
// This is defensive. The diff should in theory be always positive |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1660 |
// as RSets can only grow between GCs. However, given that we |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1661 |
// sample their size concurrently with other threads updating them |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1662 |
// it's possible that we might get the wrong size back, which |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1663 |
// could make the calculations somewhat inaccurate. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1664 |
size_t diffs = (size_t) (-_inc_cset_recorded_rs_lengths_diffs); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1665 |
if (_inc_cset_recorded_rs_lengths >= diffs) { |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1666 |
_inc_cset_recorded_rs_lengths -= diffs; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1667 |
} else { |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1668 |
_inc_cset_recorded_rs_lengths = 0; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1669 |
} |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1670 |
} |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1671 |
_inc_cset_predicted_elapsed_time_ms += |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1672 |
_inc_cset_predicted_elapsed_time_ms_diffs; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1673 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1674 |
_inc_cset_recorded_rs_lengths_diffs = 0; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1675 |
_inc_cset_predicted_elapsed_time_ms_diffs = 0.0; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1676 |
} |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1677 |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1678 |
void G1CollectorPolicy::add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1679 |
// This routine is used when: |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1680 |
// * adding survivor regions to the incremental cset at the end of an |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1681 |
// evacuation pause, |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1682 |
// * adding the current allocation region to the incremental cset |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1683 |
// when it is retired, and |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1684 |
// * updating existing policy information for a region in the |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1685 |
// incremental cset via young list RSet sampling. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1686 |
// Therefore this routine may be called at a safepoint by the |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1687 |
// VM thread, or in-between safepoints by mutator threads (when |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1688 |
// retiring the current allocation region) or a concurrent |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1689 |
// refine thread (RSet sampling). |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1690 |
|
13482 | 1691 |
double region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1692 |
size_t used_bytes = hr->used(); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1693 |
_inc_cset_recorded_rs_lengths += rs_length; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1694 |
_inc_cset_predicted_elapsed_time_ms += region_elapsed_time_ms; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1695 |
_inc_cset_bytes_used_before += used_bytes; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1696 |
|
22551 | 1697 |
// Cache the values we have added to the aggregated information |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1698 |
// in the heap region in case we have to remove this region from |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1699 |
// the incremental collection set, or it is updated by the |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1700 |
// rset sampling code |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1701 |
hr->set_recorded_rs_length(rs_length); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1702 |
hr->set_predicted_elapsed_time_ms(region_elapsed_time_ms); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1703 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1704 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1705 |
void G1CollectorPolicy::update_incremental_cset_info(HeapRegion* hr, |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1706 |
size_t new_rs_length) { |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1707 |
// Update the CSet information that is dependent on the new RS length |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1708 |
assert(hr->is_young(), "Precondition"); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1709 |
assert(!SafepointSynchronize::is_at_safepoint(), |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1710 |
"should not be at a safepoint"); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1711 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1712 |
// We could have updated _inc_cset_recorded_rs_lengths and |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1713 |
// _inc_cset_predicted_elapsed_time_ms directly but we'd need to do |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1714 |
// that atomically, as this code is executed by a concurrent |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1715 |
// refinement thread, potentially concurrently with a mutator thread |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1716 |
// allocating a new region and also updating the same fields. To |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1717 |
// avoid the atomic operations we accumulate these updates on two |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1718 |
// separate fields (*_diffs) and we'll just add them to the "main" |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1719 |
// fields at the start of a GC. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1720 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1721 |
ssize_t old_rs_length = (ssize_t) hr->recorded_rs_length(); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1722 |
ssize_t rs_lengths_diff = (ssize_t) new_rs_length - old_rs_length; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1723 |
_inc_cset_recorded_rs_lengths_diffs += rs_lengths_diff; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1724 |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1725 |
double old_elapsed_time_ms = hr->predicted_elapsed_time_ms(); |
13482 | 1726 |
double new_region_elapsed_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1727 |
double elapsed_ms_diff = new_region_elapsed_time_ms - old_elapsed_time_ms; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1728 |
_inc_cset_predicted_elapsed_time_ms_diffs += elapsed_ms_diff; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1729 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1730 |
hr->set_recorded_rs_length(new_rs_length); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1731 |
hr->set_predicted_elapsed_time_ms(new_region_elapsed_time_ms); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1732 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1733 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1734 |
void G1CollectorPolicy::add_region_to_incremental_cset_common(HeapRegion* hr) { |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1735 |
assert(hr->is_young(), "invariant"); |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1736 |
assert(hr->young_index_in_cset() > -1, "should have already been set"); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1737 |
assert(_inc_cset_build_state == Active, "Precondition"); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1738 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1739 |
// We need to clear and set the cached recorded/cached collection set |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1740 |
// information in the heap region here (before the region gets added |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1741 |
// to the collection set). An individual heap region's cached values |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1742 |
// are calculated, aggregated with the policy collection set info, |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1743 |
// and cached in the heap region here (initially) and (subsequently) |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1744 |
// by the Young List sampling code. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1745 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1746 |
size_t rs_length = hr->rem_set()->occupied(); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1747 |
add_to_incremental_cset_info(hr, rs_length); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1748 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1749 |
HeapWord* hr_end = hr->end(); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1750 |
_inc_cset_max_finger = MAX2(_inc_cset_max_finger, hr_end); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1751 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1752 |
assert(!hr->in_collection_set(), "invariant"); |
29470
e34bbcd36e53
8030646: track collection set membership in one place
ehelin
parents:
29465
diff
changeset
|
1753 |
_g1->register_young_region_with_cset(hr); |
e34bbcd36e53
8030646: track collection set membership in one place
ehelin
parents:
29465
diff
changeset
|
1754 |
assert(hr->next_in_collection_set() == NULL, "invariant"); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1755 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1756 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1757 |
// Add the region at the RHS of the incremental cset |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1758 |
void G1CollectorPolicy::add_region_to_incremental_cset_rhs(HeapRegion* hr) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1759 |
// We should only ever be appending survivors at the end of a pause |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1760 |
assert(hr->is_survivor(), "Logic"); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1761 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1762 |
// Do the 'common' stuff |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1763 |
add_region_to_incremental_cset_common(hr); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1764 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1765 |
// Now add the region at the right hand side |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1766 |
if (_inc_cset_tail == NULL) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1767 |
assert(_inc_cset_head == NULL, "invariant"); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1768 |
_inc_cset_head = hr; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1769 |
} else { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1770 |
_inc_cset_tail->set_next_in_collection_set(hr); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1771 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1772 |
_inc_cset_tail = hr; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1773 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1774 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1775 |
// Add the region to the LHS of the incremental cset |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1776 |
void G1CollectorPolicy::add_region_to_incremental_cset_lhs(HeapRegion* hr) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1777 |
// Survivors should be added to the RHS at the end of a pause |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1778 |
assert(hr->is_eden(), "Logic"); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1779 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1780 |
// Do the 'common' stuff |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1781 |
add_region_to_incremental_cset_common(hr); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1782 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1783 |
// Add the region at the left hand side |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1784 |
hr->set_next_in_collection_set(_inc_cset_head); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1785 |
if (_inc_cset_head == NULL) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1786 |
assert(_inc_cset_tail == NULL, "Invariant"); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1787 |
_inc_cset_tail = hr; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1788 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1789 |
_inc_cset_head = hr; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1790 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1791 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1792 |
#ifndef PRODUCT |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1793 |
void G1CollectorPolicy::print_collection_set(HeapRegion* list_head, outputStream* st) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1794 |
assert(list_head == inc_cset_head() || list_head == collection_set(), "must be"); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1795 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1796 |
st->print_cr("\nCollection_set:"); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1797 |
HeapRegion* csr = list_head; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1798 |
while (csr != NULL) { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1799 |
HeapRegion* next = csr->next_in_collection_set(); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1800 |
assert(csr->in_collection_set(), "bad CS"); |
12508
d76458352d62
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
12382
diff
changeset
|
1801 |
st->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", |
d76458352d62
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
12382
diff
changeset
|
1802 |
HR_FORMAT_PARAMS(csr), |
d76458352d62
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
12382
diff
changeset
|
1803 |
csr->prev_top_at_mark_start(), csr->next_top_at_mark_start(), |
d76458352d62
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
12382
diff
changeset
|
1804 |
csr->age_in_surv_rate_group_cond()); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1805 |
csr = next; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1806 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1807 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1808 |
#endif // !PRODUCT |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1809 |
|
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1810 |
double G1CollectorPolicy::reclaimable_bytes_perc(size_t reclaimable_bytes) { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1811 |
// Returns the given amount of reclaimable bytes (that represents |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1812 |
// the amount of reclaimable space still to be collected) as a |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1813 |
// percentage of the current heap capacity. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1814 |
size_t capacity_bytes = _g1->capacity(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1815 |
return (double) reclaimable_bytes * 100.0 / (double) capacity_bytes; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1816 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1817 |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1818 |
bool G1CollectorPolicy::next_gc_should_be_mixed(const char* true_action_str, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1819 |
const char* false_action_str) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1820 |
CollectionSetChooser* cset_chooser = _collectionSetChooser; |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1821 |
if (cset_chooser->is_empty()) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1822 |
ergo_verbose0(ErgoMixedGCs, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1823 |
false_action_str, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1824 |
ergo_format_reason("candidate old regions not available")); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1825 |
return false; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1826 |
} |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1827 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1828 |
// Is the amount of uncollected reclaimable space above G1HeapWastePercent? |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1829 |
size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1830 |
double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); |
12228
15ffdb8224fe
7146246: G1: expose some of the -XX flags that drive which old regions to collect during mixed GCs
tonyp
parents:
11756
diff
changeset
|
1831 |
double threshold = (double) G1HeapWastePercent; |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1832 |
if (reclaimable_perc <= threshold) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1833 |
ergo_verbose4(ErgoMixedGCs, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1834 |
false_action_str, |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1835 |
ergo_format_reason("reclaimable percentage not over threshold") |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1836 |
ergo_format_region("candidate old regions") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1837 |
ergo_format_byte_perc("reclaimable") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1838 |
ergo_format_perc("threshold"), |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1839 |
cset_chooser->remaining_regions(), |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1840 |
reclaimable_bytes, |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1841 |
reclaimable_perc, threshold); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1842 |
return false; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1843 |
} |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1844 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1845 |
ergo_verbose4(ErgoMixedGCs, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1846 |
true_action_str, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1847 |
ergo_format_reason("candidate old regions available") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1848 |
ergo_format_region("candidate old regions") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1849 |
ergo_format_byte_perc("reclaimable") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1850 |
ergo_format_perc("threshold"), |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1851 |
cset_chooser->remaining_regions(), |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1852 |
reclaimable_bytes, |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1853 |
reclaimable_perc, threshold); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1854 |
return true; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1855 |
} |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1856 |
|
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1857 |
uint G1CollectorPolicy::calc_min_old_cset_length() { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1858 |
// The min old CSet region bound is based on the maximum desired |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1859 |
// number of mixed GCs after a cycle. I.e., even if some old regions |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1860 |
// look expensive, we should add them to the CSet anyway to make |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1861 |
// sure we go through the available old regions in no more than the |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1862 |
// maximum desired number of mixed GCs. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1863 |
// |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1864 |
// The calculation is based on the number of marked regions we added |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1865 |
// to the CSet chooser in the first place, not how many remain, so |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1866 |
// that the result is the same during all mixed GCs that follow a cycle. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1867 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1868 |
const size_t region_num = (size_t) _collectionSetChooser->length(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1869 |
const size_t gc_num = (size_t) MAX2(G1MixedGCCountTarget, (uintx) 1); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1870 |
size_t result = region_num / gc_num; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1871 |
// emulate ceiling |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1872 |
if (result * gc_num < region_num) { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1873 |
result += 1; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1874 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1875 |
return (uint) result; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1876 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1877 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1878 |
uint G1CollectorPolicy::calc_max_old_cset_length() { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1879 |
// The max old CSet region bound is based on the threshold expressed |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1880 |
// as a percentage of the heap size. I.e., it should bound the |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1881 |
// number of old regions added to the CSet irrespective of how many |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1882 |
// of them are available. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1883 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1884 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
1885 |
const size_t region_num = g1h->num_regions(); |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1886 |
const size_t perc = (size_t) G1OldCSetRegionThresholdPercent; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1887 |
size_t result = region_num * perc / 100; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1888 |
// emulate ceiling |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1889 |
if (100 * result < region_num * perc) { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1890 |
result += 1; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1891 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1892 |
return (uint) result; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1893 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1894 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1895 |
|
18025 | 1896 |
void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInfo& evacuation_info) { |
13482 | 1897 |
double young_start_time_sec = os::elapsedTime(); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
1898 |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1899 |
YoungList* young_list = _g1->young_list(); |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
1900 |
finalize_incremental_cset_building(); |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1901 |
|
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1902 |
guarantee(target_pause_time_ms > 0.0, |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1903 |
err_msg("target_pause_time_ms = %1.6lf should be positive", |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1904 |
target_pause_time_ms)); |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
1905 |
guarantee(_collection_set == NULL, "Precondition"); |
1374 | 1906 |
|
1907 |
double base_time_ms = predict_base_elapsed_time_ms(_pending_cards); |
|
1908 |
double predicted_pause_time_ms = base_time_ms; |
|
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1909 |
double time_remaining_ms = MAX2(target_pause_time_ms - base_time_ms, 0.0); |
1374 | 1910 |
|
13482 | 1911 |
ergo_verbose4(ErgoCSetConstruction | ErgoHigh, |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1912 |
"start choosing CSet", |
13482 | 1913 |
ergo_format_size("_pending_cards") |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1914 |
ergo_format_ms("predicted base time") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1915 |
ergo_format_ms("remaining time") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1916 |
ergo_format_ms("target pause time"), |
13482 | 1917 |
_pending_cards, base_time_ms, time_remaining_ms, target_pause_time_ms); |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1918 |
|
11249 | 1919 |
_last_gc_was_young = gcs_are_young() ? true : false; |
1920 |
||
1921 |
if (_last_gc_was_young) { |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
1922 |
_trace_young_gen_time_data.increment_young_collection_count(); |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1923 |
} else { |
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
1924 |
_trace_young_gen_time_data.increment_mixed_collection_count(); |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1925 |
} |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1926 |
|
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1927 |
// The young list is laid with the survivor regions from the previous |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1928 |
// pause are appended to the RHS of the young list, i.e. |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1929 |
// [Newly Young Regions ++ Survivors from last pause]. |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1930 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1931 |
uint survivor_region_length = young_list->survivor_length(); |
29465
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
1932 |
uint eden_region_length = young_list->eden_length(); |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1933 |
init_cset_region_lengths(eden_region_length, survivor_region_length); |
13482 | 1934 |
|
1935 |
HeapRegion* hr = young_list->first_survivor_region(); |
|
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1936 |
while (hr != NULL) { |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1937 |
assert(hr->is_survivor(), "badly formed young list"); |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1938 |
// There is a convention that all the young regions in the CSet |
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1939 |
// are tagged as "eden", so we do this for the survivors here. We |
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1940 |
// use the special set_eden_pre_gc() as it doesn't check that the |
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1941 |
// region is free (which is not the case here). |
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26157
diff
changeset
|
1942 |
hr->set_eden_pre_gc(); |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1943 |
hr = hr->get_next_young_region(); |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1944 |
} |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1945 |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1946 |
// Clear the fields that point to the survivor list - they are all young now. |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1947 |
young_list->clear_survivors(); |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1948 |
|
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1949 |
_collection_set = _inc_cset_head; |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1950 |
_collection_set_bytes_used_before = _inc_cset_bytes_used_before; |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1951 |
time_remaining_ms = MAX2(time_remaining_ms - _inc_cset_predicted_elapsed_time_ms, 0.0); |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1952 |
predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1953 |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1954 |
ergo_verbose3(ErgoCSetConstruction | ErgoHigh, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1955 |
"add young regions to CSet", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1956 |
ergo_format_region("eden") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1957 |
ergo_format_region("survivors") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1958 |
ergo_format_ms("predicted young region time"), |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
1959 |
eden_region_length, survivor_region_length, |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1960 |
_inc_cset_predicted_elapsed_time_ms); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1961 |
|
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1962 |
// The number of recorded young regions is the incremental |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1963 |
// collection set's current size |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1964 |
set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1965 |
|
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1966 |
double young_end_time_sec = os::elapsedTime(); |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
1967 |
phase_times()->record_young_cset_choice_time_ms((young_end_time_sec - young_start_time_sec) * 1000.0); |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1968 |
|
13482 | 1969 |
// Set the start of the non-young choice time. |
1970 |
double non_young_start_time_sec = young_end_time_sec; |
|
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
1971 |
|
11249 | 1972 |
if (!gcs_are_young()) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1973 |
CollectionSetChooser* cset_chooser = _collectionSetChooser; |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1974 |
cset_chooser->verify(); |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1975 |
const uint min_old_cset_length = calc_min_old_cset_length(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1976 |
const uint max_old_cset_length = calc_max_old_cset_length(); |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1977 |
|
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
1978 |
uint expensive_region_num = 0; |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1979 |
bool check_time_remaining = adaptive_young_list_length(); |
13482 | 1980 |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1981 |
HeapRegion* hr = cset_chooser->peek(); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1982 |
while (hr != NULL) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1983 |
if (old_cset_region_length() >= max_old_cset_length) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1984 |
// Added maximum number of old regions to the CSet. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1985 |
ergo_verbose2(ErgoCSetConstruction, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1986 |
"finish adding old regions to CSet", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1987 |
ergo_format_reason("old CSet region num reached max") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1988 |
ergo_format_region("old") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1989 |
ergo_format_region("max"), |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1990 |
old_cset_region_length(), max_old_cset_length); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1991 |
break; |
1374 | 1992 |
} |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
1993 |
|
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1994 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1995 |
// Stop adding regions if the remaining reclaimable space is |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1996 |
// not above G1HeapWastePercent. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1997 |
size_t reclaimable_bytes = cset_chooser->remaining_reclaimable_bytes(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1998 |
double reclaimable_perc = reclaimable_bytes_perc(reclaimable_bytes); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1999 |
double threshold = (double) G1HeapWastePercent; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2000 |
if (reclaimable_perc <= threshold) { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2001 |
// We've added enough old regions that the amount of uncollected |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2002 |
// reclaimable space is at or below the waste threshold. Stop |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2003 |
// adding old regions to the CSet. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2004 |
ergo_verbose5(ErgoCSetConstruction, |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2005 |
"finish adding old regions to CSet", |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2006 |
ergo_format_reason("reclaimable percentage not over threshold") |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2007 |
ergo_format_region("old") |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2008 |
ergo_format_region("max") |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2009 |
ergo_format_byte_perc("reclaimable") |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2010 |
ergo_format_perc("threshold"), |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2011 |
old_cset_region_length(), |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2012 |
max_old_cset_length, |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2013 |
reclaimable_bytes, |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2014 |
reclaimable_perc, threshold); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2015 |
break; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2016 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2017 |
|
13482 | 2018 |
double predicted_time_ms = predict_region_elapsed_time_ms(hr, gcs_are_young()); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2019 |
if (check_time_remaining) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2020 |
if (predicted_time_ms > time_remaining_ms) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2021 |
// Too expensive for the current CSet. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2022 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2023 |
if (old_cset_region_length() >= min_old_cset_length) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2024 |
// We have added the minimum number of old regions to the CSet, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2025 |
// we are done with this CSet. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2026 |
ergo_verbose4(ErgoCSetConstruction, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2027 |
"finish adding old regions to CSet", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2028 |
ergo_format_reason("predicted time is too high") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2029 |
ergo_format_ms("predicted time") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2030 |
ergo_format_ms("remaining time") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2031 |
ergo_format_region("old") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2032 |
ergo_format_region("min"), |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2033 |
predicted_time_ms, time_remaining_ms, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2034 |
old_cset_region_length(), min_old_cset_length); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2035 |
break; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2036 |
} |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2037 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2038 |
// We'll add it anyway given that we haven't reached the |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2039 |
// minimum number of old regions. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2040 |
expensive_region_num += 1; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2041 |
} |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2042 |
} else { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2043 |
if (old_cset_region_length() >= min_old_cset_length) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2044 |
// In the non-auto-tuning case, we'll finish adding regions |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2045 |
// to the CSet if we reach the minimum. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2046 |
ergo_verbose2(ErgoCSetConstruction, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2047 |
"finish adding old regions to CSet", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2048 |
ergo_format_reason("old CSet region num reached min") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2049 |
ergo_format_region("old") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2050 |
ergo_format_region("min"), |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2051 |
old_cset_region_length(), min_old_cset_length); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2052 |
break; |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2053 |
} |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2054 |
} |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2055 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2056 |
// We will add this region to the CSet. |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
2057 |
time_remaining_ms = MAX2(time_remaining_ms - predicted_time_ms, 0.0); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2058 |
predicted_pause_time_ms += predicted_time_ms; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2059 |
cset_chooser->remove_and_move_to_next(hr); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2060 |
_g1->old_set_remove(hr); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2061 |
add_old_region_to_cset(hr); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2062 |
|
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2063 |
hr = cset_chooser->peek(); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2064 |
} |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2065 |
if (hr == NULL) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2066 |
ergo_verbose0(ErgoCSetConstruction, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2067 |
"finish adding old regions to CSet", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2068 |
ergo_format_reason("candidate old regions not available")); |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2069 |
} |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2070 |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2071 |
if (expensive_region_num > 0) { |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2072 |
// We print the information once here at the end, predicated on |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2073 |
// whether we added any apparently expensive regions or not, to |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2074 |
// avoid generating output per region. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2075 |
ergo_verbose4(ErgoCSetConstruction, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2076 |
"added expensive regions to CSet", |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2077 |
ergo_format_reason("old CSet region num not reached min") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2078 |
ergo_format_region("old") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2079 |
ergo_format_region("expensive") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2080 |
ergo_format_region("min") |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2081 |
ergo_format_ms("remaining time"), |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2082 |
old_cset_region_length(), |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2083 |
expensive_region_num, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2084 |
min_old_cset_length, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2085 |
time_remaining_ms); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2086 |
} |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
2087 |
|
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
2088 |
cset_chooser->verify(); |
1374 | 2089 |
} |
2090 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
2091 |
stop_incremental_cset_building(); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
2092 |
|
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2093 |
ergo_verbose5(ErgoCSetConstruction, |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2094 |
"finish choosing CSet", |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2095 |
ergo_format_region("eden") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2096 |
ergo_format_region("survivors") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2097 |
ergo_format_region("old") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2098 |
ergo_format_ms("predicted pause time") |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2099 |
ergo_format_ms("target pause time"), |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
2100 |
eden_region_length, survivor_region_length, |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
2101 |
old_cset_region_length(), |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2102 |
predicted_pause_time_ms, target_pause_time_ms); |
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
2103 |
|
1374 | 2104 |
double non_young_end_time_sec = os::elapsedTime(); |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
2105 |
phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0); |
18025 | 2106 |
evacuation_info.set_collectionset_regions(cset_region_length()); |
1374 | 2107 |
} |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2108 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2109 |
void TraceYoungGenTimeData::record_start_collection(double time_to_stop_the_world_ms) { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2110 |
if(TraceYoungGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2111 |
_all_stop_world_times_ms.add(time_to_stop_the_world_ms); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2112 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2113 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2114 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2115 |
void TraceYoungGenTimeData::record_yield_time(double yield_time_ms) { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2116 |
if(TraceYoungGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2117 |
_all_yield_times_ms.add(yield_time_ms); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2118 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2119 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2120 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2121 |
void TraceYoungGenTimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2122 |
if(TraceYoungGenTime) { |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2123 |
_total.add(pause_time_ms); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2124 |
_other.add(pause_time_ms - phase_times->accounted_time_ms()); |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
2125 |
_root_region_scan_wait.add(phase_times->root_region_scan_wait_time_ms()); |
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
2126 |
_parallel.add(phase_times->cur_collection_par_time_ms()); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2127 |
_ext_root_scan.add(phase_times->average_time_ms(G1GCPhaseTimes::ExtRootScan)); |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2128 |
_satb_filtering.add(phase_times->average_time_ms(G1GCPhaseTimes::SATBFiltering)); |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2129 |
_update_rs.add(phase_times->average_time_ms(G1GCPhaseTimes::UpdateRS)); |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2130 |
_scan_rs.add(phase_times->average_time_ms(G1GCPhaseTimes::ScanRS)); |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2131 |
_obj_copy.add(phase_times->average_time_ms(G1GCPhaseTimes::ObjCopy)); |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2132 |
_termination.add(phase_times->average_time_ms(G1GCPhaseTimes::Termination)); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2133 |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2134 |
double parallel_known_time = phase_times->average_time_ms(G1GCPhaseTimes::ExtRootScan) + |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2135 |
phase_times->average_time_ms(G1GCPhaseTimes::SATBFiltering) + |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2136 |
phase_times->average_time_ms(G1GCPhaseTimes::UpdateRS) + |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2137 |
phase_times->average_time_ms(G1GCPhaseTimes::ScanRS) + |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2138 |
phase_times->average_time_ms(G1GCPhaseTimes::ObjCopy) + |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
29470
diff
changeset
|
2139 |
phase_times->average_time_ms(G1GCPhaseTimes::Termination); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2140 |
|
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
2141 |
double parallel_other_time = phase_times->cur_collection_par_time_ms() - parallel_known_time; |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2142 |
_parallel_other.add(parallel_other_time); |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13482
diff
changeset
|
2143 |
_clear_ct.add(phase_times->cur_clear_ct_time_ms()); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2144 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2145 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2146 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2147 |
void TraceYoungGenTimeData::increment_young_collection_count() { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2148 |
if(TraceYoungGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2149 |
++_young_pause_num; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2150 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2151 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2152 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2153 |
void TraceYoungGenTimeData::increment_mixed_collection_count() { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2154 |
if(TraceYoungGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2155 |
++_mixed_pause_num; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2156 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2157 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2158 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2159 |
void TraceYoungGenTimeData::print_summary(const char* str, |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2160 |
const NumberSeq* seq) const { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2161 |
double sum = seq->sum(); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2162 |
gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)", |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2163 |
str, sum / 1000.0, seq->avg()); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2164 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2165 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2166 |
void TraceYoungGenTimeData::print_summary_sd(const char* str, |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2167 |
const NumberSeq* seq) const { |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2168 |
print_summary(str, seq); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2169 |
gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)", |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2170 |
"(num", seq->num(), seq->sd(), seq->maximum()); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2171 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2172 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2173 |
void TraceYoungGenTimeData::print() const { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2174 |
if (!TraceYoungGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2175 |
return; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2176 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2177 |
|
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2178 |
gclog_or_tty->print_cr("ALL PAUSES"); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2179 |
print_summary_sd(" Total", &_total); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
2180 |
gclog_or_tty->cr(); |
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
2181 |
gclog_or_tty->cr(); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2182 |
gclog_or_tty->print_cr(" Young GC Pauses: %8d", _young_pause_num); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2183 |
gclog_or_tty->print_cr(" Mixed GC Pauses: %8d", _mixed_pause_num); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
2184 |
gclog_or_tty->cr(); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2185 |
|
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2186 |
gclog_or_tty->print_cr("EVACUATION PAUSES"); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2187 |
|
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2188 |
if (_young_pause_num == 0 && _mixed_pause_num == 0) { |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2189 |
gclog_or_tty->print_cr("none"); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2190 |
} else { |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2191 |
print_summary_sd(" Evacuation Pauses", &_total); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2192 |
print_summary(" Root Region Scan Wait", &_root_region_scan_wait); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2193 |
print_summary(" Parallel Time", &_parallel); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2194 |
print_summary(" Ext Root Scanning", &_ext_root_scan); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2195 |
print_summary(" SATB Filtering", &_satb_filtering); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2196 |
print_summary(" Update RS", &_update_rs); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2197 |
print_summary(" Scan RS", &_scan_rs); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2198 |
print_summary(" Object Copy", &_obj_copy); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2199 |
print_summary(" Termination", &_termination); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2200 |
print_summary(" Parallel Other", &_parallel_other); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2201 |
print_summary(" Clear CT", &_clear_ct); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2202 |
print_summary(" Other", &_other); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2203 |
} |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
23854
diff
changeset
|
2204 |
gclog_or_tty->cr(); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2205 |
|
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2206 |
gclog_or_tty->print_cr("MISC"); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2207 |
print_summary_sd(" Stop World", &_all_stop_world_times_ms); |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
2208 |
print_summary_sd(" Yields", &_all_yield_times_ms); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2209 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2210 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2211 |
void TraceOldGenTimeData::record_full_collection(double full_gc_time_ms) { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2212 |
if (TraceOldGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2213 |
_all_full_gc_times.add(full_gc_time_ms); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2214 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2215 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2216 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2217 |
void TraceOldGenTimeData::print() const { |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
24424
diff
changeset
|
2218 |
if (!TraceOldGenTime) { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2219 |
return; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2220 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2221 |
|
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2222 |
if (_all_full_gc_times.num() > 0) { |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2223 |
gclog_or_tty->print("\n%4d full_gcs: total time = %8.2f s", |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2224 |
_all_full_gc_times.num(), |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2225 |
_all_full_gc_times.sum() / 1000.0); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2226 |
gclog_or_tty->print_cr(" (avg = %8.2fms).", _all_full_gc_times.avg()); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2227 |
gclog_or_tty->print_cr(" [std. dev = %8.2f ms, max = %8.2f ms]", |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2228 |
_all_full_gc_times.sd(), |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2229 |
_all_full_gc_times.maximum()); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2230 |
} |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12630
diff
changeset
|
2231 |
} |