author | tschatzl |
Tue, 13 Oct 2015 14:49:13 +0200 | |
changeset 33204 | b8a3901ac5b3 |
parent 33130 | a776072941e8 |
child 33214 | 5a00fba36171 |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
30764 | 2 |
* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. |
1374 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5350
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5350
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5350
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
30764 | 25 |
#ifndef SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP |
26 |
#define SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP |
|
7397 | 27 |
|
30764 | 28 |
#include "gc/g1/collectionSetChooser.hpp" |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
29 |
#include "gc/g1/g1CollectorState.hpp" |
32378
8dd0e7359751
8133470: Uses of Atomic methods in plab.hpp should be moved to .inline.hpp file
tschatzl
parents:
31331
diff
changeset
|
30 |
#include "gc/g1/g1InCSetState.hpp" |
30764 | 31 |
#include "gc/g1/g1MMUTracker.hpp" |
32 |
#include "gc/shared/collectorPolicy.hpp" |
|
7397 | 33 |
|
1374 | 34 |
// A G1CollectorPolicy makes policy decisions that determine the |
35 |
// characteristics of the collector. Examples include: |
|
36 |
// * choice of collection set. |
|
37 |
// * when to collect. |
|
38 |
||
39 |
class HeapRegion; |
|
40 |
class CollectionSetChooser; |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
41 |
class G1GCPhaseTimes; |
1374 | 42 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
43 |
// TraceYoungGenTime collects data on _both_ young and mixed evacuation pauses |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
44 |
// (the latter may contain non-young regions - i.e. regions that are |
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
45 |
// technically in old) while TraceOldGenTime collects data about full GCs. |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
46 |
class TraceYoungGenTimeData : public CHeapObj<mtGC> { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
47 |
private: |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
48 |
unsigned _young_pause_num; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
49 |
unsigned _mixed_pause_num; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
50 |
|
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
51 |
NumberSeq _all_stop_world_times_ms; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
52 |
NumberSeq _all_yield_times_ms; |
1374 | 53 |
|
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
54 |
NumberSeq _total; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
55 |
NumberSeq _other; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
56 |
NumberSeq _root_region_scan_wait; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
57 |
NumberSeq _parallel; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
58 |
NumberSeq _ext_root_scan; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
59 |
NumberSeq _satb_filtering; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
60 |
NumberSeq _update_rs; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
61 |
NumberSeq _scan_rs; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
62 |
NumberSeq _obj_copy; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
63 |
NumberSeq _termination; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
64 |
NumberSeq _parallel_other; |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
65 |
NumberSeq _clear_ct; |
1374 | 66 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
67 |
void print_summary(const char* str, const NumberSeq* seq) const; |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
68 |
void print_summary_sd(const char* str, const NumberSeq* seq) const; |
1374 | 69 |
|
70 |
public: |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
71 |
TraceYoungGenTimeData() : _young_pause_num(0), _mixed_pause_num(0) {}; |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
72 |
void record_start_collection(double time_to_stop_the_world_ms); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
73 |
void record_yield_time(double yield_time_ms); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
74 |
void record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times); |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
75 |
void increment_young_collection_count(); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
76 |
void increment_mixed_collection_count(); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
77 |
void print() const; |
1374 | 78 |
}; |
79 |
||
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
80 |
class TraceOldGenTimeData : public CHeapObj<mtGC> { |
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
81 |
private: |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
82 |
NumberSeq _all_full_gc_times; |
1374 | 83 |
|
12781
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
84 |
public: |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
85 |
void record_full_collection(double full_gc_time_ms); |
dd6480eea079
7172279: G1: Clean up TraceGen0Time and TraceGen1Time data gathering
brutisso
parents:
12625
diff
changeset
|
86 |
void print() const; |
1374 | 87 |
}; |
88 |
||
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
89 |
// There are three command line options related to the young gen size: |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
90 |
// NewSize, MaxNewSize and NewRatio (There is also -Xmn, but that is |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
91 |
// just a short form for NewSize==MaxNewSize). G1 will use its internal |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
92 |
// heuristics to calculate the actual young gen size, so these options |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
93 |
// basically only limit the range within which G1 can pick a young gen |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
94 |
// size. Also, these are general options taking byte sizes. G1 will |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
95 |
// internally work with a number of regions instead. So, some rounding |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
96 |
// will occur. |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
97 |
// |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
98 |
// If nothing related to the the young gen size is set on the command |
15089 | 99 |
// line we should allow the young gen to be between G1NewSizePercent |
100 |
// and G1MaxNewSizePercent of the heap size. This means that every time |
|
101 |
// the heap size changes, the limits for the young gen size will be |
|
102 |
// recalculated. |
|
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
103 |
// |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
104 |
// If only -XX:NewSize is set we should use the specified value as the |
15089 | 105 |
// minimum size for young gen. Still using G1MaxNewSizePercent of the |
106 |
// heap as maximum. |
|
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
107 |
// |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
108 |
// If only -XX:MaxNewSize is set we should use the specified value as the |
15089 | 109 |
// maximum size for young gen. Still using G1NewSizePercent of the heap |
110 |
// as minimum. |
|
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
111 |
// |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
112 |
// If -XX:NewSize and -XX:MaxNewSize are both specified we use these values. |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
113 |
// No updates when the heap size changes. There is a special case when |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
114 |
// NewSize==MaxNewSize. This is interpreted as "fixed" and will use a |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
115 |
// different heuristic for calculating the collection set when we do mixed |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
116 |
// collection. |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
117 |
// |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
118 |
// If only -XX:NewRatio is set we should use the specified ratio of the heap |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
119 |
// as both min and max. This will be interpreted as "fixed" just like the |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
120 |
// NewSize==MaxNewSize case above. But we will update the min and max |
22551 | 121 |
// every time the heap size changes. |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
122 |
// |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
123 |
// NewSize and MaxNewSize override NewRatio. So, NewRatio is ignored if it is |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
124 |
// combined with either NewSize or MaxNewSize. (A warning message is printed.) |
13195 | 125 |
class G1YoungGenSizer : public CHeapObj<mtGC> { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
126 |
private: |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
127 |
enum SizerKind { |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
128 |
SizerDefaults, |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
129 |
SizerNewSizeOnly, |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
130 |
SizerMaxNewSizeOnly, |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
131 |
SizerMaxAndNewSize, |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
132 |
SizerNewRatio |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
133 |
}; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
134 |
SizerKind _sizer_kind; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
135 |
uint _min_desired_young_length; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
136 |
uint _max_desired_young_length; |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
137 |
bool _adaptive_size; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
138 |
uint calculate_default_min_length(uint new_number_of_heap_regions); |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
139 |
uint calculate_default_max_length(uint new_number_of_heap_regions); |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
140 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
141 |
// Update the given values for minimum and maximum young gen length in regions |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
142 |
// given the number of heap regions depending on the kind of sizing algorithm. |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
143 |
void recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
144 |
|
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
145 |
public: |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
146 |
G1YoungGenSizer(); |
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
147 |
// Calculate the maximum length of the young gen given the number of regions |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
148 |
// depending on the sizing algorithm. |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
149 |
uint max_young_length(uint number_of_heap_regions); |
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
150 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
151 |
void heap_size_changed(uint new_number_of_heap_regions); |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
152 |
uint min_desired_young_length() { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
153 |
return _min_desired_young_length; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
154 |
} |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
155 |
uint max_desired_young_length() { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
156 |
return _max_desired_young_length; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
157 |
} |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
158 |
bool adaptive_young_list_length() const { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
159 |
return _adaptive_size; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
160 |
} |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
161 |
}; |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
162 |
|
1374 | 163 |
class G1CollectorPolicy: public CollectorPolicy { |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
164 |
private: |
1374 | 165 |
// either equal to the number of parallel threads, if ParallelGCThreads |
166 |
// has been set, or 1 otherwise |
|
167 |
int _parallel_gc_threads; |
|
168 |
||
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
169 |
// The number of GC threads currently active. |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
170 |
uintx _no_of_gc_threads; |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
171 |
|
1374 | 172 |
enum SomePrivateConstants { |
3697
ea9211aa02f5
6819085: G1: use larger and/or user settable region size
tonyp
parents:
3691
diff
changeset
|
173 |
NumPrevPausesForHeuristics = 10 |
1374 | 174 |
}; |
175 |
||
176 |
G1MMUTracker* _mmu_tracker; |
|
177 |
||
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
178 |
void initialize_alignments(); |
1374 | 179 |
void initialize_flags(); |
180 |
||
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
181 |
CollectionSetChooser* _collectionSetChooser; |
1374 | 182 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
183 |
double _full_collection_start_sec; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
184 |
uint _cur_collection_pause_used_regions_at_start; |
3590
a268fa66d7fb
6819077: G1: first GC thread coming late into the GC.
johnc
parents:
3191
diff
changeset
|
185 |
|
1374 | 186 |
// These exclude marking times. |
187 |
TruncatedSeq* _recent_gc_times_ms; |
|
188 |
||
189 |
TruncatedSeq* _concurrent_mark_remark_times_ms; |
|
190 |
TruncatedSeq* _concurrent_mark_cleanup_times_ms; |
|
191 |
||
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
192 |
TraceYoungGenTimeData _trace_young_gen_time_data; |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
193 |
TraceOldGenTimeData _trace_old_gen_time_data; |
1374 | 194 |
|
195 |
double _stop_world_start; |
|
196 |
||
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
197 |
uint _young_list_target_length; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
198 |
uint _young_list_fixed_length; |
1374 | 199 |
|
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
200 |
// The max number of regions we can extend the eden by while the GC |
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
201 |
// locker is active. This should be >= _young_list_target_length; |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
202 |
uint _young_list_max_length; |
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
203 |
|
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
204 |
SurvRateGroup* _short_lived_surv_rate_group; |
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
205 |
SurvRateGroup* _survivor_surv_rate_group; |
1374 | 206 |
// add here any more surv rate groups |
207 |
||
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
208 |
double _gc_overhead_perc; |
5240 | 209 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
210 |
double _reserve_factor; |
24941
4ebbe176a7b1
8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents:
22552
diff
changeset
|
211 |
uint _reserve_regions; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
212 |
|
1374 | 213 |
enum PredictionConstants { |
214 |
TruncatedSeqLength = 10 |
|
215 |
}; |
|
216 |
||
217 |
TruncatedSeq* _alloc_rate_ms_seq; |
|
218 |
double _prev_collection_pause_end_ms; |
|
219 |
||
220 |
TruncatedSeq* _rs_length_diff_seq; |
|
221 |
TruncatedSeq* _cost_per_card_ms_seq; |
|
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33130
diff
changeset
|
222 |
TruncatedSeq* _cost_scan_hcc_seq; |
11249 | 223 |
TruncatedSeq* _young_cards_per_entry_ratio_seq; |
224 |
TruncatedSeq* _mixed_cards_per_entry_ratio_seq; |
|
1374 | 225 |
TruncatedSeq* _cost_per_entry_ms_seq; |
11249 | 226 |
TruncatedSeq* _mixed_cost_per_entry_ms_seq; |
1374 | 227 |
TruncatedSeq* _cost_per_byte_ms_seq; |
228 |
TruncatedSeq* _constant_other_time_ms_seq; |
|
229 |
TruncatedSeq* _young_other_cost_per_region_ms_seq; |
|
230 |
TruncatedSeq* _non_young_other_cost_per_region_ms_seq; |
|
231 |
||
232 |
TruncatedSeq* _pending_cards_seq; |
|
233 |
TruncatedSeq* _rs_lengths_seq; |
|
234 |
||
235 |
TruncatedSeq* _cost_per_byte_ms_during_cm_seq; |
|
236 |
||
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
237 |
G1YoungGenSizer* _young_gen_sizer; |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
238 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
239 |
uint _eden_cset_region_length; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
240 |
uint _survivor_cset_region_length; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
241 |
uint _old_cset_region_length; |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
242 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
243 |
void init_cset_region_lengths(uint eden_cset_region_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
244 |
uint survivor_cset_region_length); |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
245 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
246 |
uint eden_cset_region_length() const { return _eden_cset_region_length; } |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
247 |
uint survivor_cset_region_length() const { return _survivor_cset_region_length; } |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
248 |
uint old_cset_region_length() const { return _old_cset_region_length; } |
1374 | 249 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
250 |
uint _free_regions_at_end_of_collection; |
1374 | 251 |
|
252 |
size_t _recorded_rs_lengths; |
|
253 |
size_t _max_rs_lengths; |
|
254 |
double _sigma; |
|
255 |
||
256 |
size_t _rs_lengths_prediction; |
|
257 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
258 |
double sigma() const { return _sigma; } |
1374 | 259 |
|
260 |
// A function that prevents us putting too much stock in small sample |
|
261 |
// sets. Returns a number between 2.0 and 1.0, depending on the number |
|
262 |
// of samples. 5 or more samples yields one; fewer scales linearly from |
|
263 |
// 2.0 at 1 sample to 1.0 at 5. |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
264 |
double confidence_factor(int samples) const { |
1374 | 265 |
if (samples > 4) return 1.0; |
266 |
else return 1.0 + sigma() * ((double)(5 - samples))/2.0; |
|
267 |
} |
|
268 |
||
269 |
double get_new_neg_prediction(TruncatedSeq* seq) { |
|
270 |
return seq->davg() - sigma() * seq->dsd(); |
|
271 |
} |
|
272 |
||
273 |
#ifndef PRODUCT |
|
274 |
bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group); |
|
275 |
#endif // PRODUCT |
|
276 |
||
4481 | 277 |
void adjust_concurrent_refinement(double update_rs_time, |
278 |
double update_rs_processed_buffers, |
|
279 |
double goal_ms); |
|
280 |
||
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
281 |
uintx no_of_gc_threads() { return _no_of_gc_threads; } |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
282 |
void set_no_of_gc_threads(uintx v) { _no_of_gc_threads = v; } |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
283 |
|
1374 | 284 |
double _pause_time_target_ms; |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
285 |
|
1374 | 286 |
size_t _pending_cards; |
287 |
||
288 |
public: |
|
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
289 |
// Accessors |
1374 | 290 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
291 |
void set_region_eden(HeapRegion* hr, int young_index_in_cset) { |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
24941
diff
changeset
|
292 |
hr->set_eden(); |
1374 | 293 |
hr->install_surv_rate_group(_short_lived_surv_rate_group); |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
294 |
hr->set_young_index_in_cset(young_index_in_cset); |
1374 | 295 |
} |
296 |
||
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
297 |
void set_region_survivor(HeapRegion* hr, int young_index_in_cset) { |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
24941
diff
changeset
|
298 |
assert(hr->is_survivor(), "pre-condition"); |
1374 | 299 |
hr->install_surv_rate_group(_survivor_surv_rate_group); |
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
300 |
hr->set_young_index_in_cset(young_index_in_cset); |
1374 | 301 |
} |
302 |
||
303 |
#ifndef PRODUCT |
|
304 |
bool verify_young_ages(); |
|
305 |
#endif // PRODUCT |
|
306 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
307 |
double get_new_prediction(TruncatedSeq* seq) const { |
1374 | 308 |
return MAX2(seq->davg() + sigma() * seq->dsd(), |
309 |
seq->davg() * confidence_factor(seq->num())); |
|
310 |
} |
|
311 |
||
312 |
void record_max_rs_lengths(size_t rs_lengths) { |
|
313 |
_max_rs_lengths = rs_lengths; |
|
314 |
} |
|
315 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
316 |
size_t predict_rs_length_diff() const { |
1374 | 317 |
return (size_t) get_new_prediction(_rs_length_diff_seq); |
318 |
} |
|
319 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
320 |
double predict_alloc_rate_ms() const { |
1374 | 321 |
return get_new_prediction(_alloc_rate_ms_seq); |
322 |
} |
|
323 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
324 |
double predict_cost_per_card_ms() const { |
1374 | 325 |
return get_new_prediction(_cost_per_card_ms_seq); |
326 |
} |
|
327 |
||
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33130
diff
changeset
|
328 |
double predict_scan_hcc_ms() const { |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33130
diff
changeset
|
329 |
return get_new_prediction(_cost_scan_hcc_seq); |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33130
diff
changeset
|
330 |
} |
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33130
diff
changeset
|
331 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
332 |
double predict_rs_update_time_ms(size_t pending_cards) const { |
33204
b8a3901ac5b3
8069330: Adjustment of concurrent refinement thresholds does not take hot card cache into account
tschatzl
parents:
33130
diff
changeset
|
333 |
return (double) pending_cards * predict_cost_per_card_ms() + predict_scan_hcc_ms(); |
1374 | 334 |
} |
335 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
336 |
double predict_young_cards_per_entry_ratio() const { |
11249 | 337 |
return get_new_prediction(_young_cards_per_entry_ratio_seq); |
1374 | 338 |
} |
339 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
340 |
double predict_mixed_cards_per_entry_ratio() const { |
11249 | 341 |
if (_mixed_cards_per_entry_ratio_seq->num() < 2) { |
342 |
return predict_young_cards_per_entry_ratio(); |
|
343 |
} else { |
|
344 |
return get_new_prediction(_mixed_cards_per_entry_ratio_seq); |
|
345 |
} |
|
1374 | 346 |
} |
347 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
348 |
size_t predict_young_card_num(size_t rs_length) const { |
1374 | 349 |
return (size_t) ((double) rs_length * |
11249 | 350 |
predict_young_cards_per_entry_ratio()); |
1374 | 351 |
} |
352 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
353 |
size_t predict_non_young_card_num(size_t rs_length) const { |
1374 | 354 |
return (size_t) ((double) rs_length * |
11249 | 355 |
predict_mixed_cards_per_entry_ratio()); |
1374 | 356 |
} |
357 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
358 |
double predict_rs_scan_time_ms(size_t card_num) const { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
359 |
if (collector_state()->gcs_are_young()) { |
1374 | 360 |
return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
11249 | 361 |
} else { |
362 |
return predict_mixed_rs_scan_time_ms(card_num); |
|
363 |
} |
|
1374 | 364 |
} |
365 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
366 |
double predict_mixed_rs_scan_time_ms(size_t card_num) const { |
11249 | 367 |
if (_mixed_cost_per_entry_ms_seq->num() < 3) { |
1374 | 368 |
return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
11249 | 369 |
} else { |
370 |
return (double) (card_num * |
|
371 |
get_new_prediction(_mixed_cost_per_entry_ms_seq)); |
|
372 |
} |
|
1374 | 373 |
} |
374 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
375 |
double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) const { |
11249 | 376 |
if (_cost_per_byte_ms_during_cm_seq->num() < 3) { |
377 |
return (1.1 * (double) bytes_to_copy) * |
|
378 |
get_new_prediction(_cost_per_byte_ms_seq); |
|
379 |
} else { |
|
1374 | 380 |
return (double) bytes_to_copy * |
11249 | 381 |
get_new_prediction(_cost_per_byte_ms_during_cm_seq); |
382 |
} |
|
1374 | 383 |
} |
384 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
385 |
double predict_object_copy_time_ms(size_t bytes_to_copy) const { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
386 |
if (collector_state()->during_concurrent_mark()) { |
1374 | 387 |
return predict_object_copy_time_ms_during_cm(bytes_to_copy); |
11249 | 388 |
} else { |
1374 | 389 |
return (double) bytes_to_copy * |
11249 | 390 |
get_new_prediction(_cost_per_byte_ms_seq); |
391 |
} |
|
1374 | 392 |
} |
393 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
394 |
double predict_constant_other_time_ms() const { |
1374 | 395 |
return get_new_prediction(_constant_other_time_ms_seq); |
396 |
} |
|
397 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
398 |
double predict_young_other_time_ms(size_t young_num) const { |
11249 | 399 |
return (double) young_num * |
400 |
get_new_prediction(_young_other_cost_per_region_ms_seq); |
|
1374 | 401 |
} |
402 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
403 |
double predict_non_young_other_time_ms(size_t non_young_num) const { |
11249 | 404 |
return (double) non_young_num * |
405 |
get_new_prediction(_non_young_other_cost_per_region_ms_seq); |
|
1374 | 406 |
} |
407 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
408 |
double predict_base_elapsed_time_ms(size_t pending_cards) const; |
1374 | 409 |
double predict_base_elapsed_time_ms(size_t pending_cards, |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
410 |
size_t scanned_cards) const; |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
411 |
size_t predict_bytes_to_copy(HeapRegion* hr) const; |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
412 |
double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc) const; |
1374 | 413 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
414 |
void set_recorded_rs_lengths(size_t rs_lengths); |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
415 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
416 |
uint cset_region_length() const { return young_cset_region_length() + |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
417 |
old_cset_region_length(); } |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
418 |
uint young_cset_region_length() const { return eden_cset_region_length() + |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
419 |
survivor_cset_region_length(); } |
1374 | 420 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
421 |
double predict_survivor_regions_evac_time() const; |
2009 | 422 |
|
1374 | 423 |
void cset_regions_freed() { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
424 |
bool propagate = collector_state()->should_propagate(); |
1374 | 425 |
_short_lived_surv_rate_group->all_surviving_words_recorded(propagate); |
426 |
_survivor_surv_rate_group->all_surviving_words_recorded(propagate); |
|
427 |
// also call it on any more surv rate groups |
|
428 |
} |
|
429 |
||
430 |
G1MMUTracker* mmu_tracker() { |
|
431 |
return _mmu_tracker; |
|
432 |
} |
|
433 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
434 |
const G1MMUTracker* mmu_tracker() const { |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
435 |
return _mmu_tracker; |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
436 |
} |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
437 |
|
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
438 |
double max_pause_time_ms() const { |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
439 |
return _mmu_tracker->max_gc_time() * 1000.0; |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
440 |
} |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
441 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
442 |
double predict_remark_time_ms() const { |
1374 | 443 |
return get_new_prediction(_concurrent_mark_remark_times_ms); |
444 |
} |
|
445 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
446 |
double predict_cleanup_time_ms() const { |
1374 | 447 |
return get_new_prediction(_concurrent_mark_cleanup_times_ms); |
448 |
} |
|
449 |
||
450 |
// Returns an estimate of the survival rate of the region at yg-age |
|
451 |
// "yg_age". |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
452 |
double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) const { |
2009 | 453 |
TruncatedSeq* seq = surv_rate_group->get_seq(age); |
1374 | 454 |
if (seq->num() == 0) |
455 |
gclog_or_tty->print("BARF! age is %d", age); |
|
456 |
guarantee( seq->num() > 0, "invariant" ); |
|
457 |
double pred = get_new_prediction(seq); |
|
458 |
if (pred > 1.0) |
|
459 |
pred = 1.0; |
|
460 |
return pred; |
|
461 |
} |
|
462 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
463 |
double predict_yg_surv_rate(int age) const { |
2009 | 464 |
return predict_yg_surv_rate(age, _short_lived_surv_rate_group); |
465 |
} |
|
466 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
467 |
double accum_yg_surv_rate_pred(int age) const { |
1374 | 468 |
return _short_lived_surv_rate_group->accum_surv_rate_pred(age); |
469 |
} |
|
470 |
||
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
471 |
private: |
1374 | 472 |
// Statistics kept per GC stoppage, pause or full. |
473 |
TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec; |
|
474 |
||
475 |
// Add a new GC of the given duration and end time to the record. |
|
476 |
void update_recent_gc_times(double end_time_sec, double elapsed_ms); |
|
477 |
||
478 |
// The head of the list (via "next_in_collection_set()") representing the |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
479 |
// current collection set. Set from the incrementally built collection |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
480 |
// set at the start of the pause. |
1374 | 481 |
HeapRegion* _collection_set; |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
482 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
483 |
// The number of bytes in the collection set before the pause. Set from |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
484 |
// the incrementally built collection set at the start of an evacuation |
32744
3628aefe13d5
8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents:
32737
diff
changeset
|
485 |
// pause, and incremented in finalize_old_cset_part() when adding old regions |
13482 | 486 |
// (if any) to the collection set. |
1374 | 487 |
size_t _collection_set_bytes_used_before; |
488 |
||
13482 | 489 |
// The number of bytes copied during the GC. |
490 |
size_t _bytes_copied_during_gc; |
|
491 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
492 |
// The associated information that is maintained while the incremental |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
493 |
// collection set is being built with young regions. Used to populate |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
494 |
// the recorded info for the evacuation pause. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
495 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
496 |
enum CSetBuildType { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
497 |
Active, // We are actively building the collection set |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
498 |
Inactive // We are not actively building the collection set |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
499 |
}; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
500 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
501 |
CSetBuildType _inc_cset_build_state; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
502 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
503 |
// The head of the incrementally built collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
504 |
HeapRegion* _inc_cset_head; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
505 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
506 |
// The tail of the incrementally built collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
507 |
HeapRegion* _inc_cset_tail; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
508 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
509 |
// The number of bytes in the incrementally built collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
510 |
// Used to set _collection_set_bytes_used_before at the start of |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
511 |
// an evacuation pause. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
512 |
size_t _inc_cset_bytes_used_before; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
513 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
514 |
// Used to record the highest end of heap region in collection set |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
515 |
HeapWord* _inc_cset_max_finger; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
516 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
517 |
// The RSet lengths recorded for regions in the CSet. It is updated |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
518 |
// by the thread that adds a new region to the CSet. We assume that |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
519 |
// only one thread can be allocating a new CSet region (currently, |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
520 |
// it does so after taking the Heap_lock) hence no need to |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
521 |
// synchronize updates to this field. |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
522 |
size_t _inc_cset_recorded_rs_lengths; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
523 |
|
22551 | 524 |
// A concurrent refinement thread periodically samples the young |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
525 |
// region RSets and needs to update _inc_cset_recorded_rs_lengths as |
22551 | 526 |
// the RSets grow. Instead of having to synchronize updates to that |
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
527 |
// field we accumulate them in this field and add it to |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
528 |
// _inc_cset_recorded_rs_lengths_diffs at the start of a GC. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
529 |
ssize_t _inc_cset_recorded_rs_lengths_diffs; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
530 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
531 |
// The predicted elapsed time it will take to collect the regions in |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
532 |
// the CSet. This is updated by the thread that adds a new region to |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
533 |
// the CSet. See the comment for _inc_cset_recorded_rs_lengths about |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
534 |
// MT-safety assumptions. |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
535 |
double _inc_cset_predicted_elapsed_time_ms; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
536 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
537 |
// See the comment for _inc_cset_recorded_rs_lengths_diffs. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
538 |
double _inc_cset_predicted_elapsed_time_ms_diffs; |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
539 |
|
1374 | 540 |
// Stash a pointer to the g1 heap. |
541 |
G1CollectedHeap* _g1; |
|
542 |
||
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
543 |
G1GCPhaseTimes* _phase_times; |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
544 |
|
1374 | 545 |
// The ratio of gc time to elapsed time, computed over recent pauses. |
546 |
double _recent_avg_pause_time_ratio; |
|
547 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
548 |
double recent_avg_pause_time_ratio() const { |
1374 | 549 |
return _recent_avg_pause_time_ratio; |
550 |
} |
|
551 |
||
552 |
// This set of variables tracks the collector efficiency, in order to |
|
553 |
// determine whether we should initiate a new marking. |
|
554 |
double _cur_mark_stop_world_time_ms; |
|
555 |
double _mark_remark_start_sec; |
|
556 |
double _mark_cleanup_start_sec; |
|
557 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
558 |
// Update the young list target length either by setting it to the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
559 |
// desired fixed value or by calculating it using G1's pause |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
560 |
// prediction model. If no rs_lengths parameter is passed, predict |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
561 |
// the RS lengths using the prediction model, otherwise use the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
562 |
// given rs_lengths as the prediction. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
563 |
void update_young_list_target_length(size_t rs_lengths = (size_t) -1); |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
564 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
565 |
// Calculate and return the minimum desired young list target |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
566 |
// length. This is the minimum desired young list length according |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
567 |
// to the user's inputs. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
568 |
uint calculate_young_list_desired_min_length(uint base_min_length) const; |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
569 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
570 |
// Calculate and return the maximum desired young list target |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
571 |
// length. This is the maximum desired young list length according |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
572 |
// to the user's inputs. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
573 |
uint 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
|
574 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
575 |
// Calculate and return the maximum young list target length that |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
576 |
// can fit into the pause time goal. The parameters are: rs_lengths |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
577 |
// represent the prediction of how large the young RSet lengths will |
22551 | 578 |
// be, base_min_length is the already existing number of regions in |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
579 |
// the young list, min_length and max_length are the desired min and |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
580 |
// max young list length according to the user's inputs. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
581 |
uint calculate_young_list_target_length(size_t rs_lengths, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
582 |
uint base_min_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
583 |
uint desired_min_length, |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
584 |
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
|
585 |
|
27626
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
26696
diff
changeset
|
586 |
// Calculate and return chunk size (in number of regions) for parallel |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
26696
diff
changeset
|
587 |
// concurrent mark cleanup. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
588 |
uint calculate_parallel_work_chunk_size(uint n_workers, uint n_regions) const; |
27626
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
26696
diff
changeset
|
589 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
590 |
// Check whether a given young length (young_length) fits into the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
591 |
// given target pause time and whether the prediction for the amount |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
592 |
// of objects to be copied for the given length will fit into the |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
593 |
// given free space (expressed by base_free_regions). It is used by |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
594 |
// calculate_young_list_target_length(). |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
595 |
bool predict_will_fit(uint young_length, double base_time_ms, |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
596 |
uint base_free_regions, double target_pause_time_ms) const; |
1374 | 597 |
|
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
598 |
// Calculate the minimum number of old regions we'll add to the CSet |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
599 |
// during a mixed GC. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
600 |
uint calc_min_old_cset_length() const; |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
601 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
602 |
// Calculate the maximum number of old regions we'll add to the CSet |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
603 |
// during a mixed GC. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
604 |
uint calc_max_old_cset_length() const; |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
605 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
606 |
// Returns the given amount of uncollected reclaimable space |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
607 |
// as a percentage of the current heap capacity. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
608 |
double reclaimable_bytes_perc(size_t reclaimable_bytes) const; |
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
609 |
|
1374 | 610 |
public: |
611 |
||
612 |
G1CollectorPolicy(); |
|
613 |
||
614 |
virtual G1CollectorPolicy* as_g1_policy() { return this; } |
|
615 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
616 |
const G1CollectorState* collector_state() const; |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
617 |
G1CollectorState* collector_state(); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
618 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
619 |
G1GCPhaseTimes* phase_times() const { return _phase_times; } |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
620 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
621 |
// Check the current value of the young list RSet lengths and |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
622 |
// compare it against the last prediction. If the current value is |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
623 |
// higher, recalculate the young list target length prediction. |
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
624 |
void revise_young_list_target_length_if_necessary(); |
1374 | 625 |
|
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
626 |
// This should be called after the heap is resized. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
627 |
void record_new_heap_size(uint new_number_of_regions); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
628 |
|
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
629 |
void init(); |
1374 | 630 |
|
2009 | 631 |
// Create jstat counters for the policy. |
632 |
virtual void initialize_gc_policy_counters(); |
|
633 |
||
1374 | 634 |
virtual HeapWord* mem_allocate_work(size_t size, |
635 |
bool is_tlab, |
|
636 |
bool* gc_overhead_limit_was_exceeded); |
|
637 |
||
638 |
// This method controls how a collector handles one or more |
|
639 |
// of its generations being fully allocated. |
|
640 |
virtual HeapWord* satisfy_failed_allocation(size_t size, |
|
641 |
bool is_tlab); |
|
642 |
||
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
643 |
bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0); |
11576
e0bef5ca4602
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
11455
diff
changeset
|
644 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
645 |
// Record the start and end of an evacuation pause. |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
646 |
void record_collection_pause_start(double start_time_sec); |
32737
f02118695c2f
8135154: Move cards scanned and surviving young words aggregation to G1ParScanThreadStateSet
mgerdin
parents:
32736
diff
changeset
|
647 |
void record_collection_pause_end(double pause_time_ms, size_t cards_scanned); |
1374 | 648 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
649 |
// Record the start and end of a full collection. |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
650 |
void record_full_collection_start(); |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
651 |
void record_full_collection_end(); |
1374 | 652 |
|
653 |
// Must currently be called while the world is stopped. |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
654 |
void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms); |
1374 | 655 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
656 |
// Record start and end of remark. |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
657 |
void record_concurrent_mark_remark_start(); |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
658 |
void record_concurrent_mark_remark_end(); |
1374 | 659 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
660 |
// Record start, end, and completion of cleanup. |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
661 |
void record_concurrent_mark_cleanup_start(); |
30874
18714bae50db
8080837: Move number of workers calculation out of CollectionSetChooser::prepare_for_par_region_addition
stefank
parents:
30764
diff
changeset
|
662 |
void record_concurrent_mark_cleanup_end(); |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
663 |
void record_concurrent_mark_cleanup_completed(); |
1374 | 664 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
665 |
// Records the information about the heap size for reporting in |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
666 |
// print_detailed_heap_transition |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
667 |
void record_heap_size_info_at_start(bool full); |
1374 | 668 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
669 |
// Print heap sizing transition (with less and more detail). |
29795
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
28213
diff
changeset
|
670 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
671 |
void print_heap_transition(size_t bytes_before) const; |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
672 |
void print_heap_transition() const; |
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
673 |
void print_detailed_heap_transition(bool full = false) const; |
1374 | 674 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
675 |
void record_stop_world_start(); |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
676 |
void record_concurrent_pause(); |
1374 | 677 |
|
10243
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
678 |
// Record how much space we copied during a GC. This is typically |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
679 |
// called when a GC alloc region is being retired. |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
680 |
void record_bytes_copied_during_gc(size_t bytes) { |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
681 |
_bytes_copied_during_gc += bytes; |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
682 |
} |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
683 |
|
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
684 |
// The amount of space we copied during a GC. |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
685 |
size_t bytes_copied_during_gc() const { |
10243
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
686 |
return _bytes_copied_during_gc; |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
687 |
} |
1374 | 688 |
|
32591
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
689 |
size_t collection_set_bytes_used_before() const { |
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
690 |
return _collection_set_bytes_used_before; |
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
691 |
} |
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
692 |
|
12236
51d6463cfd9d
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
11756
diff
changeset
|
693 |
// Determine whether there are candidate regions so that the |
51d6463cfd9d
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
11756
diff
changeset
|
694 |
// next GC should be mixed. The two action strings are used |
51d6463cfd9d
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
11756
diff
changeset
|
695 |
// in the ergo output when the method returns true or false. |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
696 |
bool next_gc_should_be_mixed(const char* true_action_str, |
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
697 |
const char* false_action_str) const; |
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
698 |
|
1374 | 699 |
// Choose a new collection set. Marks the chosen regions as being |
700 |
// "in_collection_set", and links them together. The head and number of |
|
701 |
// the collection set are available via access methods. |
|
32744
3628aefe13d5
8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents:
32737
diff
changeset
|
702 |
double finalize_young_cset_part(double target_pause_time_ms); |
3628aefe13d5
8135260: Split G1CollectorPolicy::finalize_cset into two parts
ehelin
parents:
32737
diff
changeset
|
703 |
virtual void finalize_old_cset_part(double time_remaining_ms); |
1374 | 704 |
|
705 |
// The head of the list (via "next_in_collection_set()") representing the |
|
706 |
// current collection set. |
|
707 |
HeapRegion* collection_set() { return _collection_set; } |
|
708 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
709 |
void clear_collection_set() { _collection_set = NULL; } |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
710 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
711 |
// Add old region "hr" to the CSet. |
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
712 |
void add_old_region_to_cset(HeapRegion* hr); |
1374 | 713 |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
714 |
// Incremental CSet Support |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
715 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
716 |
// The head of the incrementally built collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
717 |
HeapRegion* inc_cset_head() { return _inc_cset_head; } |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
718 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
719 |
// The tail of the incrementally built collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
720 |
HeapRegion* inc_set_tail() { return _inc_cset_tail; } |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
721 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
722 |
// Initialize incremental collection set info. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
723 |
void start_incremental_cset_building(); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
724 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
725 |
// Perform any final calculations on the incremental CSet fields |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
726 |
// before we can use them. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
727 |
void finalize_incremental_cset_building(); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
728 |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
729 |
void clear_incremental_cset() { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
730 |
_inc_cset_head = NULL; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
731 |
_inc_cset_tail = NULL; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
732 |
} |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
733 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
734 |
// Stop adding regions to the incremental collection set |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
735 |
void stop_incremental_cset_building() { _inc_cset_build_state = Inactive; } |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
736 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
737 |
// Add information about hr to the aggregated information for the |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
738 |
// incrementally built collection set. |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
739 |
void add_to_incremental_cset_info(HeapRegion* hr, size_t rs_length); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
740 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
741 |
// Update information about hr in the aggregated information for |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
742 |
// the incrementally built collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
743 |
void update_incremental_cset_info(HeapRegion* hr, size_t new_rs_length); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
744 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
745 |
private: |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
746 |
// Update the incremental cset information when adding a region |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
747 |
// (should not be called directly). |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
748 |
void add_region_to_incremental_cset_common(HeapRegion* hr); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
749 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
750 |
public: |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
751 |
// Add hr to the LHS of the incremental collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
752 |
void add_region_to_incremental_cset_lhs(HeapRegion* hr); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
753 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
754 |
// Add hr to the RHS of the incremental collection set. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
755 |
void add_region_to_incremental_cset_rhs(HeapRegion* hr); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
756 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
757 |
#ifndef PRODUCT |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
758 |
void print_collection_set(HeapRegion* list_head, outputStream* st); |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
759 |
#endif // !PRODUCT |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
760 |
|
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
761 |
// This sets the initiate_conc_mark_if_possible() flag to start a |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
762 |
// new cycle, as long as we are not already in one. It's best if it |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
763 |
// is called during a safepoint when the test whether a cycle is in |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
764 |
// progress or not is stable. |
10523
cdb54c167ab0
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
10281
diff
changeset
|
765 |
bool force_initial_mark_if_outside_cycle(GCCause::Cause gc_cause); |
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
766 |
|
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
767 |
// This is called at the very beginning of an evacuation pause (it |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
768 |
// has to be the first thing that the pause does). If |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
769 |
// initiate_conc_mark_if_possible() is true, and the concurrent |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
770 |
// marking thread has completed its work during the previous cycle, |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
771 |
// it will set during_initial_mark_pause() to so that the pause does |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
772 |
// the initial-mark work and start a marking cycle. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
773 |
void decide_on_conc_mark_initiation(); |
1374 | 774 |
|
775 |
// If an expansion would be appropriate, because recent GC overhead had |
|
776 |
// exceeded the desired limit, return an amount to expand by. |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
777 |
virtual size_t expansion_amount() const; |
1374 | 778 |
|
779 |
// Print tracing information. |
|
780 |
void print_tracing_info() const; |
|
781 |
||
782 |
// Print stats on young survival ratio |
|
783 |
void print_yg_surv_rate_info() const; |
|
784 |
||
2009 | 785 |
void finished_recalculating_age_indexes(bool is_survivors) { |
786 |
if (is_survivors) { |
|
787 |
_survivor_surv_rate_group->finished_recalculating_age_indexes(); |
|
788 |
} else { |
|
789 |
_short_lived_surv_rate_group->finished_recalculating_age_indexes(); |
|
790 |
} |
|
1374 | 791 |
// do that for any other surv rate groups |
792 |
} |
|
793 |
||
22552 | 794 |
size_t young_list_target_length() const { return _young_list_target_length; } |
795 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
796 |
bool is_young_list_full() const; |
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
797 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
798 |
bool can_expand_young_list() const; |
7398 | 799 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
800 |
uint young_list_max_length() const { |
10671
431ff8629f97
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
10670
diff
changeset
|
801 |
return _young_list_max_length; |
431ff8629f97
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
10670
diff
changeset
|
802 |
} |
431ff8629f97
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
10670
diff
changeset
|
803 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
804 |
bool adaptive_young_list_length() const { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
805 |
return _young_gen_sizer->adaptive_young_list_length(); |
1374 | 806 |
} |
807 |
||
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
808 |
private: |
1374 | 809 |
// |
810 |
// Survivor regions policy. |
|
811 |
// |
|
812 |
||
813 |
// Current tenuring threshold, set to 0 if the collector reaches the |
|
13925 | 814 |
// maximum amount of survivors regions. |
815 |
uint _tenuring_threshold; |
|
1374 | 816 |
|
2009 | 817 |
// The limit on the number of regions allocated for survivors. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
818 |
uint _max_survivor_regions; |
2009 | 819 |
|
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
820 |
// For reporting purposes. |
17396
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
821 |
// The value of _heap_bytes_before_gc is also used to calculate |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
822 |
// the cost of copying. |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
823 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
824 |
size_t _eden_used_bytes_before_gc; // Eden occupancy before GC |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
825 |
size_t _survivor_used_bytes_before_gc; // Survivor occupancy before GC |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
826 |
size_t _heap_used_bytes_before_gc; // Heap occupancy before GC |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
827 |
size_t _metaspace_used_bytes_before_gc; // Metaspace occupancy before GC |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
828 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
829 |
size_t _eden_capacity_bytes_before_gc; // Eden capacity before GC |
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
830 |
size_t _heap_capacity_bytes_before_gc; // Heap capacity before GC |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
831 |
|
13925 | 832 |
// The amount of survivor regions after a collection. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
833 |
uint _recorded_survivor_regions; |
2009 | 834 |
// List of survivor regions. |
835 |
HeapRegion* _recorded_survivor_head; |
|
836 |
HeapRegion* _recorded_survivor_tail; |
|
837 |
||
838 |
ageTable _survivors_age_table; |
|
839 |
||
1374 | 840 |
public: |
18025 | 841 |
uint tenuring_threshold() const { return _tenuring_threshold; } |
1374 | 842 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
843 |
static const uint REGIONS_UNLIMITED = (uint) -1; |
2009 | 844 |
|
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
845 |
uint max_regions(InCSetState dest) const { |
28213
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
846 |
switch (dest.value()) { |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
847 |
case InCSetState::Young: |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
848 |
return _max_survivor_regions; |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
849 |
case InCSetState::Old: |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
850 |
return REGIONS_UNLIMITED; |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
851 |
default: |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32744
diff
changeset
|
852 |
assert(false, "Unknown dest state: " CSETSTATE_FORMAT, dest.value()); |
28213
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
853 |
break; |
1374 | 854 |
} |
28213
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
855 |
// keep some compilers happy |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
856 |
return 0; |
1374 | 857 |
} |
858 |
||
859 |
void note_start_adding_survivor_regions() { |
|
860 |
_survivor_surv_rate_group->start_adding_regions(); |
|
861 |
} |
|
862 |
||
863 |
void note_stop_adding_survivor_regions() { |
|
864 |
_survivor_surv_rate_group->stop_adding_regions(); |
|
865 |
} |
|
2009 | 866 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
867 |
void record_survivor_regions(uint regions, |
2009 | 868 |
HeapRegion* head, |
869 |
HeapRegion* tail) { |
|
870 |
_recorded_survivor_regions = regions; |
|
871 |
_recorded_survivor_head = head; |
|
872 |
_recorded_survivor_tail = tail; |
|
873 |
} |
|
874 |
||
33130
a776072941e8
8138969: G1CollectorPolicy should use const for applicable methods
ehelin
parents:
33105
diff
changeset
|
875 |
uint recorded_survivor_regions() const { |
3191
dd3cc90b9951
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
2881
diff
changeset
|
876 |
return _recorded_survivor_regions; |
dd3cc90b9951
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
2881
diff
changeset
|
877 |
} |
dd3cc90b9951
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
2881
diff
changeset
|
878 |
|
32736
755024a84282
8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents:
32603
diff
changeset
|
879 |
void record_age_table(ageTable* age_table) { |
755024a84282
8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents:
32603
diff
changeset
|
880 |
_survivors_age_table.merge(age_table); |
2009 | 881 |
} |
882 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
883 |
void update_max_gc_locker_expansion(); |
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
884 |
|
2009 | 885 |
// Calculates survivor space parameters. |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
886 |
void update_survivors_policy(); |
2009 | 887 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
888 |
virtual void post_heap_initialize(); |
1374 | 889 |
}; |
890 |
||
891 |
// This should move to some place more general... |
|
892 |
||
893 |
// If we have "n" measurements, and we've kept track of their "sum" and the |
|
894 |
// "sum_of_squares" of the measurements, this returns the variance of the |
|
895 |
// sequence. |
|
896 |
inline double variance(int n, double sum_of_squares, double sum) { |
|
897 |
double n_d = (double)n; |
|
898 |
double avg = sum/n_d; |
|
899 |
return (sum_of_squares - 2.0 * avg * sum + n_d * avg * avg) / n_d; |
|
900 |
} |
|
901 |
||
30764 | 902 |
#endif // SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP |