author | mgerdin |
Fri, 18 Mar 2016 15:20:43 +0100 | |
changeset 37985 | 539c597ee0fa |
parent 37262 | hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp@e7b7bc691d7d |
child 38010 | 51fe205359f8 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
35927
58bbbbb4a8c7
8148944: CollectorPolicy methods for memory allocations are specific to GenCollectorPolicy
mgerdin
parents:
35909
diff
changeset
|
2 |
* Copyright (c) 2001, 2016, 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 |
||
7397 | 25 |
#include "precompiled.hpp" |
30764 | 26 |
#include "gc/g1/concurrentG1Refine.hpp" |
27 |
#include "gc/g1/concurrentMarkThread.inline.hpp" |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
28 |
#include "gc/g1/g1Analytics.hpp" |
30764 | 29 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
30 |
#include "gc/g1/g1CollectionSet.hpp" |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35927
diff
changeset
|
31 |
#include "gc/g1/g1ConcurrentMark.hpp" |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
32 |
#include "gc/g1/g1IHOPControl.hpp" |
30764 | 33 |
#include "gc/g1/g1GCPhaseTimes.hpp" |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
34 |
#include "gc/g1/g1Policy.hpp" |
37041 | 35 |
#include "gc/g1/g1YoungGenSizer.hpp" |
32185
49a57ff2c3cb
8073052: Rename and clean up the allocation manager hierarchy in g1Allocator.?pp
tschatzl
parents:
31619
diff
changeset
|
36 |
#include "gc/g1/heapRegion.inline.hpp" |
30764 | 37 |
#include "gc/g1/heapRegionRemSet.hpp" |
38 |
#include "gc/shared/gcPolicyCounters.hpp" |
|
7397 | 39 |
#include "runtime/arguments.hpp" |
40 |
#include "runtime/java.hpp" |
|
41 |
#include "runtime/mutexLocker.hpp" |
|
42 |
#include "utilities/debug.hpp" |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
43 |
#include "utilities/pair.hpp" |
1374 | 44 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
45 |
G1Policy::G1Policy() : |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
46 |
_predictor(G1ConfidencePercent / 100.0), |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
47 |
_analytics(new G1Analytics(&_predictor)), |
2741 | 48 |
_pause_time_target_ms((double) MaxGCPauseMillis), |
33133
77f781548612
8138971: G1CollectorPolicy::_rs_lengths_prediction is not initialized before use
ehelin
parents:
33130
diff
changeset
|
49 |
_rs_lengths_prediction(0), |
33150
9e514d10a7bf
8138972: G1CollectorPolicy::_max_survivor_regions should be intialized in the initializer list
ehelin
parents:
33133
diff
changeset
|
50 |
_max_survivor_regions(0), |
5240 | 51 |
_survivors_age_table(true), |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
52 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
53 |
_bytes_allocated_in_old_since_last_gc(0), |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
54 |
_ihop_control(NULL), |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
55 |
_initial_mark_to_mixed() { |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
56 |
|
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
57 |
// SurvRateGroups below must be initialized after the predictor because they |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
58 |
// indirectly use it through this object passed to their constructor. |
28483
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
59 |
_short_lived_surv_rate_group = |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
60 |
new SurvRateGroup(&_predictor, "Short Lived", G1YoungSurvRateNumRegionsSummary); |
28483
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
61 |
_survivor_surv_rate_group = |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
62 |
new SurvRateGroup(&_predictor, "Survivor", G1YoungSurvRateNumRegionsSummary); |
28483
76dc30e48a6e
8068739: G1CollectoryPolicy uses uninitialized field '_sigma' in the constructor
tschatzl
parents:
28213
diff
changeset
|
63 |
|
36191
07d2ba48d1d3
8149013: Remove unused and dead code from G1CollectorPolicy
mgerdin
parents:
36102
diff
changeset
|
64 |
_phase_times = new G1GCPhaseTimes(ParallelGCThreads); |
1374 | 65 |
|
2741 | 66 |
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
|
67 |
double time_slice = (double) GCPauseIntervalMillis / 1000.0; |
1374 | 68 |
_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
|
69 |
|
1374 | 70 |
_tenuring_threshold = MaxTenuringThreshold; |
2009 | 71 |
|
5240 | 72 |
|
37080
6f33de00485c
8151604: Rely on options range checking rather than explict checks
brutisso
parents:
37070
diff
changeset
|
73 |
guarantee(G1ReservePercent <= 50, "Range checking should not allow values over 50."); |
6f33de00485c
8151604: Rely on options range checking rather than explict checks
brutisso
parents:
37070
diff
changeset
|
74 |
_reserve_factor = (double) G1ReservePercent / 100.0; |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
75 |
// 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
|
76 |
// 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
|
77 |
_reserve_regions = 0; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
78 |
|
36577
e177c49493e9
8142484: Let IHOP follow the current capacity, not the maximum capacity
tschatzl
parents:
36374
diff
changeset
|
79 |
_ihop_control = create_ihop_control(); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
80 |
} |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21558
diff
changeset
|
81 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
82 |
G1Policy::~G1Policy() { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
83 |
delete _ihop_control; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
84 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
85 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
86 |
G1CollectorState* G1Policy::collector_state() const { return _g1->collector_state(); } |
36102
84546518799d
8149820: Move G1YoungGenSizer to g1CollectorPolicy.cpp
ehelin
parents:
36090
diff
changeset
|
87 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
88 |
void G1Policy::init() { |
1374 | 89 |
// Set aside an initial future to_space. |
90 |
_g1 = G1CollectedHeap::heap(); |
|
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
91 |
_collection_set = _g1->collection_set(); |
1374 | 92 |
|
93 |
assert(Heap_lock->owned_by_self(), "Locking discipline."); |
|
94 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
95 |
_g1->collector_policy()->initialize_gc_policy_counters(); |
2009 | 96 |
|
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
97 |
if (adaptive_young_list_length()) { |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
98 |
_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
|
99 |
} else { |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
100 |
_young_list_fixed_length = _young_gen_sizer.min_desired_young_length(); |
1374 | 101 |
} |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
102 |
_young_gen_sizer.adjust_max_new_size(_g1->max_regions()); |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
103 |
|
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
104 |
_free_regions_at_end_of_collection = _g1->num_free_regions(); |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
105 |
|
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
106 |
update_young_list_max_and_target_length(); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
107 |
// 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
|
108 |
// collection set list. Initialize the per-collection set info |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
109 |
_collection_set->start_incremental_building(); |
1374 | 110 |
} |
111 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
112 |
void G1Policy::note_gc_start() { |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37170
diff
changeset
|
113 |
phase_times()->note_gc_start(); |
33739 | 114 |
} |
115 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
116 |
bool G1Policy::predict_will_fit(uint young_length, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
117 |
double base_time_ms, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
118 |
uint base_free_regions, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
119 |
double target_pause_time_ms) const { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
120 |
if (young_length >= base_free_regions) { |
1374 | 121 |
// end condition 1: not enough space for the young regions |
122 |
return false; |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
123 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
124 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
125 |
double accum_surv_rate = accum_yg_surv_rate_pred((int) young_length - 1); |
1374 | 126 |
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
|
127 |
(size_t) (accum_surv_rate * (double) HeapRegion::GrainBytes); |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
128 |
double copy_time_ms = _analytics->predict_object_copy_time_ms(bytes_to_copy, |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
129 |
collector_state()->during_concurrent_mark()); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
130 |
double young_other_time_ms = _analytics->predict_young_other_time_ms(young_length); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
131 |
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
|
132 |
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
|
133 |
// end condition 2: prediction is over the target pause time |
1374 | 134 |
return false; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
135 |
} |
1374 | 136 |
|
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
137 |
size_t free_bytes = (base_free_regions - young_length) * HeapRegion::GrainBytes; |
34134
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
138 |
|
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
139 |
// When copying, we will likely need more bytes free than is live in the region. |
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
140 |
// Add some safety margin to factor in the confidence of our guess, and the |
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
141 |
// natural expected waste. |
37262
e7b7bc691d7d
8153117: Back out JDK-8142935 until JDK-8152723 fixed
tbenson
parents:
37214
diff
changeset
|
142 |
// (100.0 / G1ConfidencePercent) is a scale factor that expresses the uncertainty |
e7b7bc691d7d
8153117: Back out JDK-8142935 until JDK-8152723 fixed
tbenson
parents:
37214
diff
changeset
|
143 |
// of the calculation: the lower the confidence, the more headroom. |
e7b7bc691d7d
8153117: Back out JDK-8142935 until JDK-8152723 fixed
tbenson
parents:
37214
diff
changeset
|
144 |
// (100 + TargetPLABWastePct) represents the increase in expected bytes during |
e7b7bc691d7d
8153117: Back out JDK-8142935 until JDK-8152723 fixed
tbenson
parents:
37214
diff
changeset
|
145 |
// copying due to anticipated waste in the PLABs. |
e7b7bc691d7d
8153117: Back out JDK-8142935 until JDK-8152723 fixed
tbenson
parents:
37214
diff
changeset
|
146 |
double safety_factor = (100.0 / G1ConfidencePercent) * (100 + TargetPLABWastePct) / 100.0; |
e7b7bc691d7d
8153117: Back out JDK-8142935 until JDK-8152723 fixed
tbenson
parents:
37214
diff
changeset
|
147 |
size_t expected_bytes_to_copy = (size_t)(safety_factor * bytes_to_copy); |
34134
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
148 |
|
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
149 |
if (expected_bytes_to_copy > free_bytes) { |
d4fd14f628fb
8138684: G1 decision about taking regions into the collection set is too aggressive
tschatzl
parents:
33811
diff
changeset
|
150 |
// end condition 3: out-of-space |
1374 | 151 |
return false; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
152 |
} |
1374 | 153 |
|
154 |
// success! |
|
155 |
return true; |
|
156 |
} |
|
157 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
158 |
void G1Policy::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
|
159 |
// re-calculate the necessary reserve |
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
160 |
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
|
161 |
// 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
|
162 |
// 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
|
163 |
_reserve_regions = (uint) ceil(reserve_regions_d); |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
164 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
165 |
_young_gen_sizer.heap_size_changed(new_number_of_regions); |
36577
e177c49493e9
8142484: Let IHOP follow the current capacity, not the maximum capacity
tschatzl
parents:
36374
diff
changeset
|
166 |
|
e177c49493e9
8142484: Let IHOP follow the current capacity, not the maximum capacity
tschatzl
parents:
36374
diff
changeset
|
167 |
_ihop_control->update_target_occupancy(new_number_of_regions * HeapRegion::GrainBytes); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
168 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
169 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
170 |
uint G1Policy::calculate_young_list_desired_min_length(uint base_min_length) const { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
171 |
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
|
172 |
if (adaptive_young_list_length()) { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
173 |
if (_analytics->num_alloc_rate_ms() > 3) { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
174 |
double now_sec = os::elapsedTime(); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
175 |
double when_ms = _mmu_tracker->when_max_gc_sec(now_sec) * 1000.0; |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
176 |
double alloc_rate_ms = _analytics->predict_alloc_rate_ms(); |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
177 |
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
|
178 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
179 |
// 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
|
180 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
181 |
} |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
182 |
desired_min_length += base_min_length; |
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
183 |
// make sure we don't go below any user-defined minimum bound |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
184 |
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
|
185 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
186 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
187 |
uint G1Policy::calculate_young_list_desired_max_length() const { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
188 |
// 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
|
189 |
// 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
|
190 |
// effectively don't set this bound. |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
191 |
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
|
192 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
193 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
194 |
uint G1Policy::update_young_list_max_and_target_length() { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
195 |
return update_young_list_max_and_target_length(_analytics->predict_rs_lengths()); |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
196 |
} |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
197 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
198 |
uint G1Policy::update_young_list_max_and_target_length(size_t rs_lengths) { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
199 |
uint unbounded_target_length = update_young_list_target_length(rs_lengths); |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
200 |
update_max_gc_locker_expansion(); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
201 |
return unbounded_target_length; |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
202 |
} |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
203 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
204 |
uint G1Policy::update_young_list_target_length(size_t rs_lengths) { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
205 |
YoungTargetLengths young_lengths = young_list_target_lengths(rs_lengths); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
206 |
_young_list_target_length = young_lengths.first; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
207 |
return young_lengths.second; |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
208 |
} |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
209 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
210 |
G1Policy::YoungTargetLengths G1Policy::young_list_target_lengths(size_t rs_lengths) const { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
211 |
YoungTargetLengths result; |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
212 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
213 |
// Calculate the absolute and desired min bounds first. |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
214 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
215 |
// This is how many young regions we already have (currently: the survivors). |
37070
a2b389f23bac
8151633: Don't keep copies of the survivor lists and counts in the G1CollectorPolicy
mgerdin
parents:
37051
diff
changeset
|
216 |
const uint base_min_length = _g1->young_list()->survivor_length(); |
29465
7c6ad4acdb78
8031538: G1 eden usage is sometimes higher than target eden (printed Eden size)
sfriberg
parents:
28832
diff
changeset
|
217 |
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
|
218 |
// 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
|
219 |
// 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
|
220 |
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
|
221 |
// 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
|
222 |
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
|
223 |
// 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
|
224 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
225 |
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
|
226 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
227 |
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
|
228 |
if (adaptive_young_list_length()) { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
229 |
if (collector_state()->gcs_are_young()) { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
230 |
young_list_target_length = |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
231 |
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
|
232 |
base_min_length, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
233 |
desired_min_length, |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
234 |
desired_max_length); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
235 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
236 |
// 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
|
237 |
// 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
|
238 |
// 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
|
239 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
240 |
} else { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
241 |
// 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
|
242 |
// 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
|
243 |
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
|
244 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
245 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
246 |
result.second = young_list_target_length; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
247 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
248 |
// We will try our best not to "eat" into the reserve. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
249 |
uint absolute_max_length = 0; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
250 |
if (_free_regions_at_end_of_collection > _reserve_regions) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
251 |
absolute_max_length = _free_regions_at_end_of_collection - _reserve_regions; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
252 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
253 |
if (desired_max_length > absolute_max_length) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
254 |
desired_max_length = absolute_max_length; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
255 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
256 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
257 |
// 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
|
258 |
// 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
|
259 |
// 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
|
260 |
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
|
261 |
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
|
262 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
263 |
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
|
264 |
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
|
265 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
266 |
|
37070
a2b389f23bac
8151633: Don't keep copies of the survivor lists and counts in the G1CollectorPolicy
mgerdin
parents:
37051
diff
changeset
|
267 |
assert(young_list_target_length > base_min_length, |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
268 |
"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
|
269 |
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
|
270 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
271 |
result.first = young_list_target_length; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
272 |
return result; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
273 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
274 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
275 |
uint |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
276 |
G1Policy::calculate_young_list_target_length(size_t rs_lengths, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
277 |
uint base_min_length, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
278 |
uint desired_min_length, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
279 |
uint desired_max_length) const { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
280 |
assert(adaptive_young_list_length(), "pre-condition"); |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
281 |
assert(collector_state()->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
|
282 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
283 |
// 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
|
284 |
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
|
285 |
return desired_min_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
286 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
287 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
288 |
// 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
|
289 |
// 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
|
290 |
// 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
|
291 |
// 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
|
292 |
// survivor_regions_evac_time prediction. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
293 |
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
|
294 |
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
|
295 |
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
|
296 |
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
|
297 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
298 |
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
|
299 |
double survivor_regions_evac_time = predict_survivor_regions_evac_time(); |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
300 |
size_t pending_cards = _analytics->predict_pending_cards(); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
301 |
size_t adj_rs_lengths = rs_lengths + _analytics->predict_rs_length_diff(); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
302 |
size_t scanned_cards = _analytics->predict_card_num(adj_rs_lengths, /* gcs_are_young */ true); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
303 |
double base_time_ms = |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
304 |
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
|
305 |
survivor_regions_evac_time; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
306 |
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
|
307 |
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
|
308 |
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
|
309 |
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
|
310 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
311 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
312 |
// 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
|
313 |
// 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
|
314 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
315 |
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
|
316 |
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
|
317 |
// 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
|
318 |
// 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
|
319 |
// 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
|
320 |
// 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
|
321 |
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
|
322 |
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
|
323 |
// 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
|
324 |
// 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
|
325 |
// 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
|
326 |
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
|
327 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
328 |
// 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
|
329 |
// 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
|
330 |
// length. The loop invariants are: |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
331 |
// |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
332 |
// 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
|
333 |
// 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
|
334 |
// 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
|
335 |
// |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
336 |
// 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
|
337 |
// 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
|
338 |
// 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
|
339 |
// 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
|
340 |
// 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
|
341 |
// 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
|
342 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
343 |
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
|
344 |
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
|
345 |
while (diff > 0) { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
346 |
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
|
347 |
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
|
348 |
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
|
349 |
min_young_length = young_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
350 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
351 |
max_young_length = young_length; |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
352 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
353 |
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
|
354 |
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
|
355 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
356 |
// 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
|
357 |
// 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
|
358 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
359 |
// 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
|
360 |
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
|
361 |
"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
|
362 |
"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
|
363 |
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
|
364 |
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
|
365 |
"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
|
366 |
"fit into the pause target"); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
367 |
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
|
368 |
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
|
369 |
"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
|
370 |
"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
|
371 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
372 |
} else { |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
373 |
// 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
|
374 |
// 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
|
375 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
376 |
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
|
377 |
} |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
378 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
379 |
double G1Policy::predict_survivor_regions_evac_time() const { |
2009 | 380 |
double survivor_regions_evac_time = 0.0; |
37070
a2b389f23bac
8151633: Don't keep copies of the survivor lists and counts in the G1CollectorPolicy
mgerdin
parents:
37051
diff
changeset
|
381 |
for (HeapRegion * r = _g1->young_list()->first_survivor_region(); |
a2b389f23bac
8151633: Don't keep copies of the survivor lists and counts in the G1CollectorPolicy
mgerdin
parents:
37051
diff
changeset
|
382 |
r != NULL && r != _g1->young_list()->last_survivor_region()->get_next_young_region(); |
2009 | 383 |
r = r->get_next_young_region()) { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
384 |
survivor_regions_evac_time += predict_region_elapsed_time_ms(r, collector_state()->gcs_are_young()); |
2009 | 385 |
} |
386 |
return survivor_regions_evac_time; |
|
387 |
} |
|
388 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
389 |
void G1Policy::revise_young_list_target_length_if_necessary(size_t rs_lengths) { |
1374 | 390 |
guarantee( adaptive_young_list_length(), "should not call this otherwise" ); |
391 |
||
392 |
if (rs_lengths > _rs_lengths_prediction) { |
|
393 |
// add 10% to avoid having to recalculate often |
|
394 |
size_t rs_lengths_prediction = rs_lengths * 1100 / 1000; |
|
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
395 |
update_rs_lengths_prediction(rs_lengths_prediction); |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
396 |
|
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
397 |
update_young_list_max_and_target_length(rs_lengths_prediction); |
1374 | 398 |
} |
399 |
} |
|
400 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
401 |
void G1Policy::update_rs_lengths_prediction() { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
402 |
update_rs_lengths_prediction(_analytics->predict_rs_lengths()); |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
403 |
} |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
404 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
405 |
void G1Policy::update_rs_lengths_prediction(size_t prediction) { |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
406 |
if (collector_state()->gcs_are_young() && adaptive_young_list_length()) { |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
407 |
_rs_lengths_prediction = prediction; |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
408 |
} |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
409 |
} |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
410 |
|
1374 | 411 |
#ifndef PRODUCT |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
412 |
bool G1Policy::verify_young_ages() { |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5347
diff
changeset
|
413 |
HeapRegion* head = _g1->young_list()->first_region(); |
1374 | 414 |
return |
415 |
verify_young_ages(head, _short_lived_surv_rate_group); |
|
416 |
// also call verify_young_ages on any additional surv rate groups |
|
417 |
} |
|
418 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
419 |
bool G1Policy::verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group) { |
1374 | 420 |
guarantee( surv_rate_group != NULL, "pre-condition" ); |
421 |
||
422 |
const char* name = surv_rate_group->name(); |
|
423 |
bool ret = true; |
|
424 |
int prev_age = -1; |
|
425 |
||
426 |
for (HeapRegion* curr = head; |
|
427 |
curr != NULL; |
|
428 |
curr = curr->get_next_young_region()) { |
|
429 |
SurvRateGroup* group = curr->surv_rate_group(); |
|
430 |
if (group == NULL && !curr->is_survivor()) { |
|
36090
cffc1dd98258
8149541: Use log_error() instead of log_info() when verification reports a problem
brutisso
parents:
35943
diff
changeset
|
431 |
log_error(gc, verify)("## %s: encountered NULL surv_rate_group", name); |
1374 | 432 |
ret = false; |
433 |
} |
|
434 |
||
435 |
if (surv_rate_group == group) { |
|
436 |
int age = curr->age_in_surv_rate_group(); |
|
437 |
||
438 |
if (age < 0) { |
|
36090
cffc1dd98258
8149541: Use log_error() instead of log_info() when verification reports a problem
brutisso
parents:
35943
diff
changeset
|
439 |
log_error(gc, verify)("## %s: encountered negative age", name); |
1374 | 440 |
ret = false; |
441 |
} |
|
442 |
||
443 |
if (age <= prev_age) { |
|
36090
cffc1dd98258
8149541: Use log_error() instead of log_info() when verification reports a problem
brutisso
parents:
35943
diff
changeset
|
444 |
log_error(gc, verify)("## %s: region ages are not strictly increasing (%d, %d)", name, age, prev_age); |
1374 | 445 |
ret = false; |
446 |
} |
|
447 |
prev_age = age; |
|
448 |
} |
|
449 |
} |
|
450 |
||
451 |
return ret; |
|
452 |
} |
|
453 |
#endif // PRODUCT |
|
454 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
455 |
void G1Policy::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
|
456 |
_full_collection_start_sec = os::elapsedTime(); |
1374 | 457 |
// Release the future to-space so that it is available for compaction into. |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
458 |
collector_state()->set_full_collection(true); |
1374 | 459 |
} |
460 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
461 |
void G1Policy::record_full_collection_end() { |
1374 | 462 |
// Consider this like a collection pause for the purposes of allocation |
463 |
// since last pause. |
|
464 |
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
|
465 |
double full_gc_time_sec = end_sec - _full_collection_start_sec; |
1374 | 466 |
double full_gc_time_ms = full_gc_time_sec * 1000.0; |
467 |
||
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
468 |
_analytics->update_recent_gc_times(end_sec, full_gc_time_ms); |
1374 | 469 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
470 |
collector_state()->set_full_collection(false); |
1374 | 471 |
|
11249 | 472 |
// "Nuke" the heuristics that control the young/mixed GC |
473 |
// transitions and make sure we start with young GCs after the Full GC. |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
474 |
collector_state()->set_gcs_are_young(true); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
475 |
collector_state()->set_last_young_gc(false); |
33809
62f8fb907ad5
8139874: After G1 Full GC, the next GC is always a young-only GC
tschatzl
parents:
33808
diff
changeset
|
476 |
collector_state()->set_initiate_conc_mark_if_possible(need_to_start_conc_mark("end of Full GC", 0)); |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
477 |
collector_state()->set_during_initial_mark_pause(false); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
478 |
collector_state()->set_in_marking_window(false); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
479 |
collector_state()->set_in_marking_window_im(false); |
1374 | 480 |
|
481 |
_short_lived_surv_rate_group->start_adding_regions(); |
|
482 |
// also call this on any additional surv rate groups |
|
483 |
||
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
484 |
_free_regions_at_end_of_collection = _g1->num_free_regions(); |
2009 | 485 |
// Reset survivors SurvRateGroup. |
486 |
_survivor_surv_rate_group->reset(); |
|
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
487 |
update_young_list_max_and_target_length(); |
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
488 |
update_rs_lengths_prediction(); |
34611
b8f6f834489b
8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents:
34300
diff
changeset
|
489 |
cset_chooser()->clear(); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
490 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
491 |
_bytes_allocated_in_old_since_last_gc = 0; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
492 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
493 |
record_pause(FullGC, _full_collection_start_sec, end_sec); |
7398 | 494 |
} |
1374 | 495 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
496 |
void G1Policy::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
|
497 |
// 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
|
498 |
// 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
|
499 |
// 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
|
500 |
update_survivors_policy(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
501 |
|
7398 | 502 |
assert(_g1->used() == _g1->recalculate_used(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32745
diff
changeset
|
503 |
"sanity, used: " SIZE_FORMAT " recalculate_used: " SIZE_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32745
diff
changeset
|
504 |
_g1->used(), _g1->recalculate_used()); |
1374 | 505 |
|
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
|
506 |
phase_times()->record_cur_collection_start_sec(start_time_sec); |
1374 | 507 |
_pending_cards = _g1->pending_card_num(); |
508 |
||
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
509 |
_collection_set->reset_bytes_used_before(); |
10243
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
510 |
_bytes_copied_during_gc = 0; |
1374 | 511 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
512 |
collector_state()->set_last_gc_was_young(false); |
1374 | 513 |
|
514 |
// do that for any other surv rate groups |
|
515 |
_short_lived_surv_rate_group->stop_adding_regions(); |
|
5033 | 516 |
_survivors_age_table.clear(); |
2009 | 517 |
|
1374 | 518 |
assert( verify_young_ages(), "region age verification" ); |
519 |
} |
|
520 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
521 |
void G1Policy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
522 |
collector_state()->set_during_marking(true); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
523 |
assert(!collector_state()->initiate_conc_mark_if_possible(), "we should have cleared it by now"); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
524 |
collector_state()->set_during_initial_mark_pause(false); |
1374 | 525 |
} |
526 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
527 |
void G1Policy::record_concurrent_mark_remark_start() { |
1374 | 528 |
_mark_remark_start_sec = os::elapsedTime(); |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
529 |
collector_state()->set_during_marking(false); |
1374 | 530 |
} |
531 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
532 |
void G1Policy::record_concurrent_mark_remark_end() { |
1374 | 533 |
double end_time_sec = os::elapsedTime(); |
534 |
double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0; |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
535 |
_analytics->report_concurrent_mark_remark_times_ms(elapsed_time_ms); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
536 |
_analytics->append_prev_collection_pause_end_ms(elapsed_time_ms); |
1374 | 537 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
538 |
record_pause(Remark, _mark_remark_start_sec, end_time_sec); |
1374 | 539 |
} |
540 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
541 |
void G1Policy::record_concurrent_mark_cleanup_start() { |
1374 | 542 |
_mark_cleanup_start_sec = os::elapsedTime(); |
543 |
} |
|
544 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
545 |
void G1Policy::record_concurrent_mark_cleanup_completed() { |
33811
b7cea7584267
8140689: Skip last young-only gc if nothing to do in the mixed gc phase
tschatzl
parents:
33810
diff
changeset
|
546 |
bool should_continue_with_reclaim = next_gc_should_be_mixed("request last young-only gc", |
b7cea7584267
8140689: Skip last young-only gc if nothing to do in the mixed gc phase
tschatzl
parents:
33810
diff
changeset
|
547 |
"skip last young-only gc"); |
b7cea7584267
8140689: Skip last young-only gc if nothing to do in the mixed gc phase
tschatzl
parents:
33810
diff
changeset
|
548 |
collector_state()->set_last_young_gc(should_continue_with_reclaim); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
549 |
// We skip the marking phase. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
550 |
if (!should_continue_with_reclaim) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
551 |
abort_time_to_mixed_tracking(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
552 |
} |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
553 |
collector_state()->set_in_marking_window(false); |
1374 | 554 |
} |
555 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
556 |
double G1Policy::average_time_ms(G1GCPhaseTimes::GCParPhases phase) const { |
33624
509a72e7127b
8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents:
33591
diff
changeset
|
557 |
return phase_times()->average_time_ms(phase); |
509a72e7127b
8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents:
33591
diff
changeset
|
558 |
} |
509a72e7127b
8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents:
33591
diff
changeset
|
559 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
560 |
double G1Policy::young_other_time_ms() const { |
33747
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
561 |
return phase_times()->young_cset_choice_time_ms() + |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
562 |
phase_times()->young_free_cset_time_ms(); |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
563 |
} |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
564 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
565 |
double G1Policy::non_young_other_time_ms() const { |
33747
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
566 |
return phase_times()->non_young_cset_choice_time_ms() + |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
567 |
phase_times()->non_young_free_cset_time_ms(); |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
568 |
|
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
569 |
} |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
570 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
571 |
double G1Policy::other_time_ms(double pause_time_ms) const { |
33747
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
572 |
return pause_time_ms - |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
573 |
average_time_ms(G1GCPhaseTimes::UpdateRS) - |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
574 |
average_time_ms(G1GCPhaseTimes::ScanRS) - |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
575 |
average_time_ms(G1GCPhaseTimes::ObjCopy) - |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
576 |
average_time_ms(G1GCPhaseTimes::Termination); |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
577 |
} |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
578 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
579 |
double G1Policy::constant_other_time_ms(double pause_time_ms) const { |
33747
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
580 |
return other_time_ms(pause_time_ms) - young_other_time_ms() - non_young_other_time_ms(); |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
581 |
} |
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
582 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
583 |
CollectionSetChooser* G1Policy::cset_chooser() const { |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
584 |
return _collection_set->cset_chooser(); |
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
585 |
} |
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
586 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
587 |
bool G1Policy::about_to_start_mixed_phase() const { |
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
588 |
return _g1->concurrent_mark()->cmThread()->during_cycle() || collector_state()->last_young_gc(); |
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
589 |
} |
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
590 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
591 |
bool G1Policy::need_to_start_conc_mark(const char* source, size_t alloc_word_size) { |
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
592 |
if (about_to_start_mixed_phase()) { |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
593 |
return false; |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
594 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
595 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
596 |
size_t marking_initiating_used_threshold = _ihop_control->get_conc_mark_start_threshold(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
597 |
|
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
598 |
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
|
599 |
size_t alloc_byte_size = alloc_word_size * HeapWordSize; |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
600 |
size_t marking_request_bytes = cur_used_bytes + alloc_byte_size; |
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
601 |
|
35061 | 602 |
bool result = false; |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
603 |
if (marking_request_bytes > marking_initiating_used_threshold) { |
35061 | 604 |
result = collector_state()->gcs_are_young() && !collector_state()->last_young_gc(); |
605 |
log_debug(gc, ergo, ihop)("%s occupancy: " SIZE_FORMAT "B allocation request: " SIZE_FORMAT "B threshold: " SIZE_FORMAT "B (%1.2f) source: %s", |
|
606 |
result ? "Request concurrent cycle initiation (occupancy higher than threshold)" : "Do not request concurrent cycle initiation (still doing mixed collections)", |
|
607 |
cur_used_bytes, alloc_byte_size, marking_initiating_used_threshold, (double) marking_initiating_used_threshold / _g1->capacity() * 100, source); |
|
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
608 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
609 |
|
35061 | 610 |
return result; |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
611 |
} |
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
612 |
|
1374 | 613 |
// Anything below that is considered to be zero |
614 |
#define MIN_TIMER_GRANULARITY 0.0000001 |
|
615 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
616 |
void G1Policy::record_collection_pause_end(double pause_time_ms, size_t cards_scanned, size_t heap_used_bytes_before_gc) { |
1374 | 617 |
double end_time_sec = os::elapsedTime(); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
618 |
|
1374 | 619 |
size_t cur_used_bytes = _g1->used(); |
620 |
assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); |
|
621 |
bool last_pause_included_initial_mark = false; |
|
6249 | 622 |
bool update_stats = !_g1->evacuation_failed(); |
1374 | 623 |
|
35061 | 624 |
NOT_PRODUCT(_short_lived_surv_rate_group->print()); |
1374 | 625 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
626 |
record_pause(young_gc_pause_kind(), end_time_sec - pause_time_ms / 1000.0, end_time_sec); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
627 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
628 |
last_pause_included_initial_mark = collector_state()->during_initial_mark_pause(); |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
629 |
if (last_pause_included_initial_mark) { |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
630 |
record_concurrent_mark_init_end(0.0); |
33810
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
631 |
} else { |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
632 |
maybe_start_marking(); |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
633 |
} |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
634 |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
635 |
double app_time_ms = (phase_times()->cur_collection_start_sec() * 1000.0 - _analytics->prev_collection_pause_end_ms()); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
636 |
if (app_time_ms < MIN_TIMER_GRANULARITY) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
637 |
// This usually happens due to the timer not having the required |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
638 |
// granularity. Some Linuxes are the usual culprits. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
639 |
// We'll just set it to something (arbitrarily) small. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
640 |
app_time_ms = 1.0; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
641 |
} |
1374 | 642 |
|
2121
0b899b36d991
6804746: G1: guarantee(variance() > -1.0,"variance should be >= 0") (due to evacuation failure)
tonyp
parents:
2011
diff
changeset
|
643 |
if (update_stats) { |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10996
diff
changeset
|
644 |
// 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
|
645 |
// 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
|
646 |
// 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
|
647 |
// 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
|
648 |
// 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
|
649 |
// 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
|
650 |
// 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
|
651 |
// place we can safely ignore them here. |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
652 |
uint regions_allocated = _collection_set->eden_region_length(); |
1374 | 653 |
double alloc_rate_ms = (double) regions_allocated / app_time_ms; |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
654 |
_analytics->report_alloc_rate_ms(alloc_rate_ms); |
1374 | 655 |
|
656 |
double interval_ms = |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
657 |
(end_time_sec - _analytics->last_known_gc_end_time_sec()) * 1000.0; |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
658 |
_analytics->update_recent_gc_times(end_time_sec, pause_time_ms); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
659 |
_analytics->compute_pause_time_ratio(interval_ms, pause_time_ms); |
1374 | 660 |
} |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
17320
diff
changeset
|
661 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
662 |
bool new_in_marking_window = collector_state()->in_marking_window(); |
1374 | 663 |
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
|
664 |
if (last_pause_included_initial_mark) { |
1374 | 665 |
new_in_marking_window = true; |
666 |
new_in_marking_window_im = true; |
|
667 |
} |
|
668 |
||
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
669 |
if (collector_state()->last_young_gc()) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
670 |
// 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
|
671 |
// doing mixed GCs. Here we decide whether to start mixed GCs or not. |
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
672 |
assert(!last_pause_included_initial_mark, "The last young GC is not allowed to be an initial mark GC"); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
673 |
|
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
674 |
if (next_gc_should_be_mixed("start mixed GCs", |
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
675 |
"do not start mixed GCs")) { |
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
676 |
collector_state()->set_gcs_are_young(false); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
677 |
} else { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
678 |
// We aborted the mixed GC phase early. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
679 |
abort_time_to_mixed_tracking(); |
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
|
680 |
} |
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
681 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
682 |
collector_state()->set_last_young_gc(false); |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
683 |
} |
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
684 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
685 |
if (!collector_state()->last_gc_was_young()) { |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
686 |
// 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
|
687 |
// mixed GCs or not. |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
688 |
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
|
689 |
"do not continue mixed GCs")) { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
690 |
collector_state()->set_gcs_are_young(true); |
33810
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
691 |
|
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
692 |
maybe_start_marking(); |
1374 | 693 |
} |
10280
3463715b5ef7
6814390: G1: remove the concept of non-generational G1
brutisso
parents:
10243
diff
changeset
|
694 |
} |
11249 | 695 |
|
1374 | 696 |
_short_lived_surv_rate_group->start_adding_regions(); |
22551 | 697 |
// Do that for any other surv rate groups |
1374 | 698 |
|
36374 | 699 |
double scan_hcc_time_ms = ConcurrentG1Refine::hot_card_cache_enabled() ? average_time_ms(G1GCPhaseTimes::ScanHCC) : 0.0; |
700 |
||
2344 | 701 |
if (update_stats) { |
1374 | 702 |
double cost_per_card_ms = 0.0; |
703 |
if (_pending_cards > 0) { |
|
36374 | 704 |
cost_per_card_ms = (average_time_ms(G1GCPhaseTimes::UpdateRS) - scan_hcc_time_ms) / (double) _pending_cards; |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
705 |
_analytics->report_cost_per_card_ms(cost_per_card_ms); |
1374 | 706 |
} |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
707 |
_analytics->report_cost_scan_hcc(scan_hcc_time_ms); |
1374 | 708 |
|
709 |
double cost_per_entry_ms = 0.0; |
|
710 |
if (cards_scanned > 10) { |
|
33624
509a72e7127b
8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents:
33591
diff
changeset
|
711 |
cost_per_entry_ms = average_time_ms(G1GCPhaseTimes::ScanRS) / (double) cards_scanned; |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
712 |
_analytics->report_cost_per_entry_ms(cost_per_entry_ms, collector_state()->last_gc_was_young()); |
1374 | 713 |
} |
714 |
||
715 |
if (_max_rs_lengths > 0) { |
|
716 |
double cards_per_entry_ratio = |
|
717 |
(double) cards_scanned / (double) _max_rs_lengths; |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
718 |
_analytics->report_cards_per_entry_ratio(cards_per_entry_ratio, collector_state()->last_gc_was_young()); |
1374 | 719 |
} |
720 |
||
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
721 |
// 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
|
722 |
// 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
|
723 |
// 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
|
724 |
// 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
|
725 |
// _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
|
726 |
// 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
|
727 |
// 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
|
728 |
// _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
|
729 |
// 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
|
730 |
// 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
|
731 |
// 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
|
732 |
// 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
|
733 |
// conditional below just in case. |
11206
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
734 |
size_t rs_length_diff = 0; |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
735 |
size_t recorded_rs_lengths = _collection_set->recorded_rs_lengths(); |
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
736 |
if (_max_rs_lengths > recorded_rs_lengths) { |
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
737 |
rs_length_diff = _max_rs_lengths - recorded_rs_lengths; |
11206
040c80ccd07f
7118202: G1: eden size unnecessarily drops to a minimum
tonyp
parents:
11176
diff
changeset
|
738 |
} |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
739 |
_analytics->report_rs_length_diff((double) rs_length_diff); |
1374 | 740 |
|
35909
cf5f3c85e179
8148736: Let the G1 heap transition log regions instead of bytes
brutisso
parents:
35907
diff
changeset
|
741 |
size_t freed_bytes = heap_used_bytes_before_gc - cur_used_bytes; |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
742 |
size_t copied_bytes = _collection_set->bytes_used_before() - freed_bytes; |
1374 | 743 |
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
|
744 |
|
1374 | 745 |
if (copied_bytes > 0) { |
33624
509a72e7127b
8140489: Introduce shorthand for average_time_ms in G1CollectorPolicy
ehelin
parents:
33591
diff
changeset
|
746 |
cost_per_byte_ms = average_time_ms(G1GCPhaseTimes::ObjCopy) / (double) copied_bytes; |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
747 |
_analytics->report_cost_per_byte_ms(cost_per_byte_ms, collector_state()->in_marking_window()); |
1374 | 748 |
} |
749 |
||
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
750 |
if (_collection_set->young_region_length() > 0) { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
751 |
_analytics->report_young_other_cost_per_region_ms(young_other_time_ms() / |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
752 |
_collection_set->young_region_length()); |
1374 | 753 |
} |
754 |
||
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
755 |
if (_collection_set->old_region_length() > 0) { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
756 |
_analytics->report_non_young_other_cost_per_region_ms(non_young_other_time_ms() / |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
757 |
_collection_set->old_region_length()); |
33747
2dfa9256eb77
8140602: Split other time calculation into methods in G1CollectorPolicy
ehelin
parents:
33739
diff
changeset
|
758 |
} |
1374 | 759 |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
760 |
_analytics->report_constant_other_time_ms(constant_other_time_ms(pause_time_ms)); |
1374 | 761 |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
762 |
_analytics->report_pending_cards((double) _pending_cards); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
763 |
_analytics->report_rs_lengths((double) _max_rs_lengths); |
1374 | 764 |
} |
765 |
||
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
766 |
collector_state()->set_in_marking_window(new_in_marking_window); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
767 |
collector_state()->set_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
|
768 |
_free_regions_at_end_of_collection = _g1->num_free_regions(); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
769 |
// IHOP control wants to know the expected young gen length if it were not |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
770 |
// restrained by the heap reserve. Using the actual length would make the |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
771 |
// prediction too small and the limit the young gen every time we get to the |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
772 |
// predicted target occupancy. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
773 |
size_t last_unrestrained_young_length = update_young_list_max_and_target_length(); |
33591
4a2823c696ce
8138975: G1CollectorPolicy::calculate_young_list_target_length should be const
ehelin
parents:
33218
diff
changeset
|
774 |
update_rs_lengths_prediction(); |
1374 | 775 |
|
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
776 |
update_ihop_prediction(app_time_ms / 1000.0, |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
777 |
_bytes_allocated_in_old_since_last_gc, |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
778 |
last_unrestrained_young_length * HeapRegion::GrainBytes); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
779 |
_bytes_allocated_in_old_since_last_gc = 0; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
780 |
|
34300 | 781 |
_ihop_control->send_trace_event(_g1->gc_tracer_stw()); |
782 |
||
4481 | 783 |
// Note that _mmu_tracker->max_gc_time() returns the time in seconds. |
5033 | 784 |
double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0; |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
785 |
|
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
786 |
if (update_rs_time_goal_ms < scan_hcc_time_ms) { |
35061 | 787 |
log_debug(gc, ergo, refine)("Adjust concurrent refinement thresholds (scanning the HCC expected to take longer than Update RS time goal)." |
788 |
"Update RS time goal: %1.2fms Scan HCC time: %1.2fms", |
|
789 |
update_rs_time_goal_ms, scan_hcc_time_ms); |
|
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
790 |
|
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
791 |
update_rs_time_goal_ms = 0; |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
792 |
} else { |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
793 |
update_rs_time_goal_ms -= scan_hcc_time_ms; |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33150
diff
changeset
|
794 |
} |
37158
b882bbfa1af0
8152101: Move G1 concurrent refinement adjustment code out of G1CollectorPolicy
mgerdin
parents:
37144
diff
changeset
|
795 |
_g1->concurrent_g1_refine()->adjust(average_time_ms(G1GCPhaseTimes::UpdateRS) - scan_hcc_time_ms, |
b882bbfa1af0
8152101: Move G1 concurrent refinement adjustment code out of G1CollectorPolicy
mgerdin
parents:
37144
diff
changeset
|
796 |
phase_times()->sum_thread_work_items(G1GCPhaseTimes::UpdateRS), |
b882bbfa1af0
8152101: Move G1 concurrent refinement adjustment code out of G1CollectorPolicy
mgerdin
parents:
37144
diff
changeset
|
797 |
update_rs_time_goal_ms); |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
798 |
|
34611
b8f6f834489b
8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents:
34300
diff
changeset
|
799 |
cset_chooser()->verify(); |
1374 | 800 |
} |
801 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
802 |
G1IHOPControl* G1Policy::create_ihop_control() const { |
34299
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
803 |
if (G1UseAdaptiveIHOP) { |
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
804 |
return new G1AdaptiveIHOPControl(InitiatingHeapOccupancyPercent, |
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
805 |
&_predictor, |
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
806 |
G1ReservePercent, |
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
807 |
G1HeapWastePercent); |
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
808 |
} else { |
36577
e177c49493e9
8142484: Let IHOP follow the current capacity, not the maximum capacity
tschatzl
parents:
36374
diff
changeset
|
809 |
return new G1StaticIHOPControl(InitiatingHeapOccupancyPercent); |
34299
3fdfdda0ac1f
8136678: Implement adaptive sizing algorithm for IHOP
tschatzl
parents:
34298
diff
changeset
|
810 |
} |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
811 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
812 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
813 |
void G1Policy::update_ihop_prediction(double mutator_time_s, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
814 |
size_t mutator_alloc_bytes, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
815 |
size_t young_gen_size) { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
816 |
// Always try to update IHOP prediction. Even evacuation failures give information |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
817 |
// about e.g. whether to start IHOP earlier next time. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
818 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
819 |
// Avoid using really small application times that might create samples with |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
820 |
// very high or very low values. They may be caused by e.g. back-to-back gcs. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
821 |
double const min_valid_time = 1e-6; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
822 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
823 |
bool report = false; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
824 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
825 |
double marking_to_mixed_time = -1.0; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
826 |
if (!collector_state()->last_gc_was_young() && _initial_mark_to_mixed.has_result()) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
827 |
marking_to_mixed_time = _initial_mark_to_mixed.last_marking_time(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
828 |
assert(marking_to_mixed_time > 0.0, |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
829 |
"Initial mark to mixed time must be larger than zero but is %.3f", |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
830 |
marking_to_mixed_time); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
831 |
if (marking_to_mixed_time > min_valid_time) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
832 |
_ihop_control->update_marking_length(marking_to_mixed_time); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
833 |
report = true; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
834 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
835 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
836 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
837 |
// As an approximation for the young gc promotion rates during marking we use |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
838 |
// all of them. In many applications there are only a few if any young gcs during |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
839 |
// marking, which makes any prediction useless. This increases the accuracy of the |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
840 |
// prediction. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
841 |
if (collector_state()->last_gc_was_young() && mutator_time_s > min_valid_time) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
842 |
_ihop_control->update_allocation_info(mutator_time_s, mutator_alloc_bytes, young_gen_size); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
843 |
report = true; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
844 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
845 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
846 |
if (report) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
847 |
report_ihop_statistics(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
848 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
849 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
850 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
851 |
void G1Policy::report_ihop_statistics() { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
852 |
_ihop_control->print(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
853 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
854 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
855 |
void G1Policy::print_phases() { |
35907
57bdb6243428
8148734: G1: Make G1GCPhaseTimes keep track of the start GC time
brutisso
parents:
35887
diff
changeset
|
856 |
phase_times()->print(); |
33738
1708291bd3d7
8140508: Add utility method for logging phases to G1CollectorPolicy
ehelin
parents:
33624
diff
changeset
|
857 |
} |
1708291bd3d7
8140508: Add utility method for logging phases to G1CollectorPolicy
ehelin
parents:
33624
diff
changeset
|
858 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
859 |
double G1Policy::predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const { |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
860 |
TruncatedSeq* seq = surv_rate_group->get_seq(age); |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
861 |
guarantee(seq->num() > 0, "There should be some young gen survivor samples available. Tried to access with age %d", age); |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
862 |
double pred = _predictor.get_new_prediction(seq); |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
863 |
if (pred > 1.0) { |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
864 |
pred = 1.0; |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
865 |
} |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
866 |
return pred; |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
867 |
} |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
868 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
869 |
double G1Policy::predict_yg_surv_rate(int age) const { |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
870 |
return predict_yg_surv_rate(age, _short_lived_surv_rate_group); |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
871 |
} |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
872 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
873 |
double G1Policy::accum_yg_surv_rate_pred(int age) const { |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
874 |
return _short_lived_surv_rate_group->accum_surv_rate_pred(age); |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
875 |
} |
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
876 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
877 |
double G1Policy::predict_base_elapsed_time_ms(size_t pending_cards, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
878 |
size_t scanned_cards) const { |
1374 | 879 |
return |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
880 |
_analytics->predict_rs_update_time_ms(pending_cards) + |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
881 |
_analytics->predict_rs_scan_time_ms(scanned_cards, collector_state()->gcs_are_young()) + |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
882 |
_analytics->predict_constant_other_time_ms(); |
1374 | 883 |
} |
884 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
885 |
double G1Policy::predict_base_elapsed_time_ms(size_t pending_cards) const { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
886 |
size_t rs_length = _analytics->predict_rs_lengths() + _analytics->predict_rs_length_diff(); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
887 |
size_t card_num = _analytics->predict_card_num(rs_length, collector_state()->gcs_are_young()); |
13482 | 888 |
return predict_base_elapsed_time_ms(pending_cards, card_num); |
1374 | 889 |
} |
890 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
891 |
size_t G1Policy::predict_bytes_to_copy(HeapRegion* hr) const { |
1374 | 892 |
size_t bytes_to_copy; |
893 |
if (hr->is_marked()) |
|
894 |
bytes_to_copy = hr->max_live_bytes(); |
|
895 |
else { |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
896 |
assert(hr->is_young() && hr->age_in_surv_rate_group() != -1, "invariant"); |
1374 | 897 |
int age = hr->age_in_surv_rate_group(); |
2009 | 898 |
double yg_surv_rate = predict_yg_surv_rate(age, hr->surv_rate_group()); |
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33204
diff
changeset
|
899 |
bytes_to_copy = (size_t) (hr->used() * yg_surv_rate); |
1374 | 900 |
} |
901 |
return bytes_to_copy; |
|
902 |
} |
|
903 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
904 |
double G1Policy::predict_region_elapsed_time_ms(HeapRegion* hr, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
905 |
bool for_young_gc) const { |
13482 | 906 |
size_t rs_length = hr->rem_set()->occupied(); |
907 |
// Predicting the number of cards is based on which type of GC |
|
908 |
// we're predicting for. |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
909 |
size_t card_num = _analytics->predict_card_num(rs_length, for_young_gc); |
13482 | 910 |
size_t bytes_to_copy = predict_bytes_to_copy(hr); |
911 |
||
912 |
double region_elapsed_time_ms = |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
913 |
_analytics->predict_rs_scan_time_ms(card_num, collector_state()->gcs_are_young()) + |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
914 |
_analytics->predict_object_copy_time_ms(bytes_to_copy, collector_state()->during_concurrent_mark()); |
13482 | 915 |
|
916 |
// The prediction of the "other" time for this region is based |
|
917 |
// upon the region type and NOT the GC type. |
|
918 |
if (hr->is_young()) { |
|
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
919 |
region_elapsed_time_ms += _analytics->predict_young_other_time_ms(1); |
13482 | 920 |
} else { |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
921 |
region_elapsed_time_ms += _analytics->predict_non_young_other_time_ms(1); |
13482 | 922 |
} |
923 |
return region_elapsed_time_ms; |
|
924 |
} |
|
925 |
||
1374 | 926 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
927 |
void G1Policy::print_yg_surv_rate_info() const { |
1374 | 928 |
#ifndef PRODUCT |
929 |
_short_lived_surv_rate_group->print_surv_rate_summary(); |
|
930 |
// add this call for any other surv rate groups |
|
931 |
#endif // PRODUCT |
|
932 |
} |
|
933 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
934 |
bool G1Policy::is_young_list_full() const { |
27892
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
935 |
uint young_list_length = _g1->young_list()->length(); |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
936 |
uint young_list_target_length = _young_list_target_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
937 |
return young_list_length >= young_list_target_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
938 |
} |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
939 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
940 |
bool G1Policy::can_expand_young_list() const { |
27892
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
941 |
uint young_list_length = _g1->young_list()->length(); |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
942 |
uint young_list_max_length = _young_list_max_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
943 |
return young_list_length < young_list_max_length; |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
944 |
} |
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
945 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
946 |
bool G1Policy::adaptive_young_list_length() const { |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
947 |
return _young_gen_sizer.adaptive_young_list_length(); |
36102
84546518799d
8149820: Move G1YoungGenSizer to g1CollectorPolicy.cpp
ehelin
parents:
36090
diff
changeset
|
948 |
} |
84546518799d
8149820: Move G1YoungGenSizer to g1CollectorPolicy.cpp
ehelin
parents:
36090
diff
changeset
|
949 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
950 |
void G1Policy::update_max_gc_locker_expansion() { |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12378
diff
changeset
|
951 |
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
|
952 |
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
|
953 |
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
|
954 |
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
|
955 |
// 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
|
956 |
// 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
|
957 |
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
|
958 |
} else { |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
959 |
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
|
960 |
} |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
961 |
_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
|
962 |
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
|
963 |
} |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
964 |
|
2009 | 965 |
// Calculates survivor space parameters. |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
966 |
void G1Policy::update_survivors_policy() { |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
967 |
double max_survivor_regions_d = |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
968 |
(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
|
969 |
// 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
|
970 |
// 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
|
971 |
_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
|
972 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
973 |
GCPolicyCounters* counters = _g1->collector_policy()->counters(); |
10281
ad7517425333
7081064: G1: remove develop params G1FixedSurvivorSpaceSize, G1FixedTenuringThreshold, and G1FixedEdenSize
tonyp
parents:
10280
diff
changeset
|
974 |
_tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
975 |
HeapRegion::GrainWords * _max_survivor_regions, counters); |
2009 | 976 |
} |
977 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
978 |
bool G1Policy::force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause) { |
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
979 |
// We actually check whether we are marking here and not if we are in a |
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
980 |
// reclamation phase. This means that we will schedule a concurrent mark |
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
981 |
// even while we are still in the process of reclaiming memory. |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
982 |
bool during_cycle = _g1->concurrent_mark()->cmThread()->during_cycle(); |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
983 |
if (!during_cycle) { |
35061 | 984 |
log_debug(gc, ergo)("Request concurrent cycle initiation (requested by GC cause). GC cause: %s", GCCause::to_string(gc_cause)); |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
985 |
collector_state()->set_initiate_conc_mark_if_possible(true); |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
986 |
return true; |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
987 |
} else { |
35061 | 988 |
log_debug(gc, ergo)("Do not request concurrent cycle initiation (concurrent cycle already in progress). GC cause: %s", GCCause::to_string(gc_cause)); |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
989 |
return false; |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
990 |
} |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
991 |
} |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
992 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
993 |
void G1Policy::initiate_conc_mark() { |
34619
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
994 |
collector_state()->set_during_initial_mark_pause(true); |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
995 |
collector_state()->set_initiate_conc_mark_if_possible(false); |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
996 |
} |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
997 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
998 |
void G1Policy::decide_on_conc_mark_initiation() { |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
999 |
// 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
|
1000 |
// initial-mark pause. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1001 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
1002 |
// First, collector_state()->during_initial_mark_pause() should not be already set. We |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1003 |
// 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
|
1004 |
// 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
|
1005 |
// initial-mark pause). |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
1006 |
assert(!collector_state()->during_initial_mark_pause(), "pre-condition"); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1007 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
1008 |
if (collector_state()->initiate_conc_mark_if_possible()) { |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1009 |
// 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
|
1010 |
// 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
|
1011 |
// concurrent marking cycle. So we might initiate one. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1012 |
|
33808
ee899178e46b
8140597: Forcing an initial mark causes G1 to abort mixed collections
tschatzl
parents:
33771
diff
changeset
|
1013 |
if (!about_to_start_mixed_phase() && collector_state()->gcs_are_young()) { |
34619
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1014 |
// Initiate a new initial mark if there is no marking or reclamation going on. |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1015 |
initiate_conc_mark(); |
35061 | 1016 |
log_debug(gc, ergo)("Initiate concurrent cycle (concurrent cycle initiation requested)"); |
34619
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1017 |
} else if (_g1->is_user_requested_concurrent_full_gc(_g1->gc_cause())) { |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1018 |
// Initiate a user requested initial mark. An initial mark must be young only |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1019 |
// GC, so the collector state must be updated to reflect this. |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1020 |
collector_state()->set_gcs_are_young(true); |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1021 |
collector_state()->set_last_young_gc(false); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1022 |
|
34619
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1023 |
abort_time_to_mixed_tracking(); |
83b1fedf01e9
8143251: HeapRetentionTest.java Test is failing on jdk9/dev
sjohanss
parents:
34611
diff
changeset
|
1024 |
initiate_conc_mark(); |
35061 | 1025 |
log_debug(gc, ergo)("Initiate concurrent cycle (user requested concurrent cycle)"); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1026 |
} else { |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1027 |
// The concurrent marking thread is still finishing up the |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1028 |
// 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
|
1029 |
// overlap. In particular, the concurrent marking thread might |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1030 |
// 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
|
1031 |
// 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
|
1032 |
// 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
|
1033 |
// 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
|
1034 |
// 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
|
1035 |
// periodically yields while clearing the next marking bitmap |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1036 |
// 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
|
1037 |
// 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
|
1038 |
// let the concurrent marking thread complete the last one. |
35061 | 1039 |
log_debug(gc, ergo)("Do not initiate concurrent cycle (concurrent cycle already in progress)"); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1040 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1041 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1042 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
1043 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1044 |
void G1Policy::record_concurrent_mark_cleanup_end() { |
37143
345ad6728be3
8151637: Move CollectionSetChooser rebuild code into CollectionSetChooser
mgerdin
parents:
37134
diff
changeset
|
1045 |
cset_chooser()->rebuild(_g1->workers(), _g1->num_regions()); |
12382
6aaecb1cbfe1
7145441: G1: collection set chooser-related cleanup
tonyp
parents:
12381
diff
changeset
|
1046 |
|
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1047 |
double end_sec = os::elapsedTime(); |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10677
diff
changeset
|
1048 |
double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0; |
37134
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
1049 |
_analytics->report_concurrent_mark_cleanup_times_ms(elapsed_time_ms); |
9dd3975ca940
8151711: Move G1 number sequences out of the G1 collector policy
mgerdin
parents:
37080
diff
changeset
|
1050 |
_analytics->append_prev_collection_pause_end_ms(elapsed_time_ms); |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1051 |
|
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1052 |
record_pause(Cleanup, _mark_cleanup_start_sec, end_sec); |
1374 | 1053 |
} |
1054 |
||
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1055 |
double G1Policy::reclaimable_bytes_perc(size_t reclaimable_bytes) const { |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1056 |
// 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
|
1057 |
// 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
|
1058 |
// percentage of the current heap capacity. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1059 |
size_t capacity_bytes = _g1->capacity(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1060 |
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
|
1061 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1062 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1063 |
void G1Policy::maybe_start_marking() { |
33810
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1064 |
if (need_to_start_conc_mark("end of GC")) { |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1065 |
// Note: this might have already been set, if during the last |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1066 |
// pause we decided to start a cycle but at the beginning of |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1067 |
// this pause we decided to postpone it. That's OK. |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1068 |
collector_state()->set_initiate_conc_mark_if_possible(true); |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1069 |
} |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1070 |
} |
8bbfb74d1f6c
8138740: Start initial mark right after mixed GC if needed
tschatzl
parents:
33809
diff
changeset
|
1071 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1072 |
G1Policy::PauseKind G1Policy::young_gc_pause_kind() const { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1073 |
assert(!collector_state()->full_collection(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1074 |
if (collector_state()->during_initial_mark_pause()) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1075 |
assert(collector_state()->last_gc_was_young(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1076 |
assert(!collector_state()->last_young_gc(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1077 |
return InitialMarkGC; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1078 |
} else if (collector_state()->last_young_gc()) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1079 |
assert(!collector_state()->during_initial_mark_pause(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1080 |
assert(collector_state()->last_gc_was_young(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1081 |
return LastYoungGC; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1082 |
} else if (!collector_state()->last_gc_was_young()) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1083 |
assert(!collector_state()->during_initial_mark_pause(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1084 |
assert(!collector_state()->last_young_gc(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1085 |
return MixedGC; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1086 |
} else { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1087 |
assert(collector_state()->last_gc_was_young(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1088 |
assert(!collector_state()->during_initial_mark_pause(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1089 |
assert(!collector_state()->last_young_gc(), "must be"); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1090 |
return YoungOnlyGC; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1091 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1092 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1093 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1094 |
void G1Policy::record_pause(PauseKind kind, double start, double end) { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1095 |
// Manage the MMU tracker. For some reason it ignores Full GCs. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1096 |
if (kind != FullGC) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1097 |
_mmu_tracker->add_pause(start, end); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1098 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1099 |
// Manage the mutator time tracking from initial mark to first mixed gc. |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1100 |
switch (kind) { |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1101 |
case FullGC: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1102 |
abort_time_to_mixed_tracking(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1103 |
break; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1104 |
case Cleanup: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1105 |
case Remark: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1106 |
case YoungOnlyGC: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1107 |
case LastYoungGC: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1108 |
_initial_mark_to_mixed.add_pause(end - start); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1109 |
break; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1110 |
case InitialMarkGC: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1111 |
_initial_mark_to_mixed.record_initial_mark_end(end); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1112 |
break; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1113 |
case MixedGC: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1114 |
_initial_mark_to_mixed.record_mixed_gc_start(start); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1115 |
break; |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1116 |
default: |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1117 |
ShouldNotReachHere(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1118 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1119 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1120 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1121 |
void G1Policy::abort_time_to_mixed_tracking() { |
34298
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1122 |
_initial_mark_to_mixed.reset(); |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1123 |
} |
f3c9dcc5af96
8136681: Factor out IHOP calculation from G1CollectorPolicy
tschatzl
parents:
34134
diff
changeset
|
1124 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1125 |
bool G1Policy::next_gc_should_be_mixed(const char* true_action_str, |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1126 |
const char* false_action_str) const { |
34611
b8f6f834489b
8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents:
34300
diff
changeset
|
1127 |
if (cset_chooser()->is_empty()) { |
35061 | 1128 |
log_debug(gc, ergo)("%s (candidate old regions not available)", false_action_str); |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1129 |
return false; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1130 |
} |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1131 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1132 |
// Is the amount of uncollected reclaimable space above G1HeapWastePercent? |
34611
b8f6f834489b
8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents:
34300
diff
changeset
|
1133 |
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
|
1134 |
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
|
1135 |
double threshold = (double) G1HeapWastePercent; |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1136 |
if (reclaimable_perc <= threshold) { |
35061 | 1137 |
log_debug(gc, ergo)("%s (reclaimable percentage not over threshold). candidate old regions: %u reclaimable: " SIZE_FORMAT " (%1.2f) threshold: " UINTX_FORMAT, |
1138 |
false_action_str, cset_chooser()->remaining_regions(), reclaimable_bytes, reclaimable_perc, G1HeapWastePercent); |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1139 |
return false; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1140 |
} |
35061 | 1141 |
log_debug(gc, ergo)("%s (candidate old regions available). candidate old regions: %u reclaimable: " SIZE_FORMAT " (%1.2f) threshold: " UINTX_FORMAT, |
1142 |
true_action_str, cset_chooser()->remaining_regions(), reclaimable_bytes, reclaimable_perc, G1HeapWastePercent); |
|
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1143 |
return true; |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1144 |
} |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
1145 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1146 |
uint G1Policy::calc_min_old_cset_length() const { |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1147 |
// 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
|
1148 |
// 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
|
1149 |
// 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
|
1150 |
// 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
|
1151 |
// maximum desired number of mixed GCs. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1152 |
// |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1153 |
// 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
|
1154 |
// 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
|
1155 |
// 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
|
1156 |
|
34611
b8f6f834489b
8144077: Add getter for G1CollectorPolicy::_collectionSetChooser
ehelin
parents:
34300
diff
changeset
|
1157 |
const size_t region_num = (size_t) cset_chooser()->length(); |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1158 |
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
|
1159 |
size_t result = region_num / gc_num; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1160 |
// emulate ceiling |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1161 |
if (result * gc_num < region_num) { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1162 |
result += 1; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1163 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1164 |
return (uint) result; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1165 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1166 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1167 |
uint G1Policy::calc_max_old_cset_length() const { |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1168 |
// 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
|
1169 |
// 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
|
1170 |
// 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
|
1171 |
// of them are available. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1172 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33107
diff
changeset
|
1173 |
const G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25727
diff
changeset
|
1174 |
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
|
1175 |
const size_t perc = (size_t) G1OldCSetRegionThresholdPercent; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1176 |
size_t result = region_num * perc / 100; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1177 |
// emulate ceiling |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1178 |
if (100 * result < region_num * perc) { |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1179 |
result += 1; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1180 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1181 |
return (uint) result; |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1182 |
} |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15806
diff
changeset
|
1183 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37262
diff
changeset
|
1184 |
void G1Policy::finalize_collection_set(double target_pause_time_ms) { |
37039
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
1185 |
double time_remaining_ms = _collection_set->finalize_young_part(target_pause_time_ms); |
79f62b89a7a6
8151178: Move the collection set out of the G1 collector policy
mgerdin
parents:
36577
diff
changeset
|
1186 |
_collection_set->finalize_old_part(time_remaining_ms); |
32744
3628aefe13d5
8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents:
32737
diff
changeset
|
1187 |
} |