author | mgerdin |
Wed, 09 Sep 2015 14:22:45 +0200 | |
changeset 32737 | f02118695c2f |
parent 32736 | 755024a84282 |
child 32744 | 3628aefe13d5 |
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 |
} |
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
158 |
bool adaptive_young_list_length() { |
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; |
|
11249 | 222 |
TruncatedSeq* _young_cards_per_entry_ratio_seq; |
223 |
TruncatedSeq* _mixed_cards_per_entry_ratio_seq; |
|
1374 | 224 |
TruncatedSeq* _cost_per_entry_ms_seq; |
11249 | 225 |
TruncatedSeq* _mixed_cost_per_entry_ms_seq; |
1374 | 226 |
TruncatedSeq* _cost_per_byte_ms_seq; |
227 |
TruncatedSeq* _constant_other_time_ms_seq; |
|
228 |
TruncatedSeq* _young_other_cost_per_region_ms_seq; |
|
229 |
TruncatedSeq* _non_young_other_cost_per_region_ms_seq; |
|
230 |
||
231 |
TruncatedSeq* _pending_cards_seq; |
|
232 |
TruncatedSeq* _rs_lengths_seq; |
|
233 |
||
234 |
TruncatedSeq* _cost_per_byte_ms_during_cm_seq; |
|
235 |
||
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
236 |
G1YoungGenSizer* _young_gen_sizer; |
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
237 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
238 |
uint _eden_cset_region_length; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
239 |
uint _survivor_cset_region_length; |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
240 |
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
|
241 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
242 |
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
|
243 |
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
|
244 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
245 |
uint eden_cset_region_length() { return _eden_cset_region_length; } |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
246 |
uint survivor_cset_region_length() { return _survivor_cset_region_length; } |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
247 |
uint old_cset_region_length() { return _old_cset_region_length; } |
1374 | 248 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
249 |
uint _free_regions_at_end_of_collection; |
1374 | 250 |
|
251 |
size_t _recorded_rs_lengths; |
|
252 |
size_t _max_rs_lengths; |
|
253 |
double _sigma; |
|
254 |
||
255 |
size_t _rs_lengths_prediction; |
|
256 |
||
11756
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
257 |
double sigma() { return _sigma; } |
1374 | 258 |
|
259 |
// A function that prevents us putting too much stock in small sample |
|
260 |
// sets. Returns a number between 2.0 and 1.0, depending on the number |
|
261 |
// of samples. 5 or more samples yields one; fewer scales linearly from |
|
262 |
// 2.0 at 1 sample to 1.0 at 5. |
|
263 |
double confidence_factor(int samples) { |
|
264 |
if (samples > 4) return 1.0; |
|
265 |
else return 1.0 + sigma() * ((double)(5 - samples))/2.0; |
|
266 |
} |
|
267 |
||
268 |
double get_new_neg_prediction(TruncatedSeq* seq) { |
|
269 |
return seq->davg() - sigma() * seq->dsd(); |
|
270 |
} |
|
271 |
||
272 |
#ifndef PRODUCT |
|
273 |
bool verify_young_ages(HeapRegion* head, SurvRateGroup *surv_rate_group); |
|
274 |
#endif // PRODUCT |
|
275 |
||
4481 | 276 |
void adjust_concurrent_refinement(double update_rs_time, |
277 |
double update_rs_processed_buffers, |
|
278 |
double goal_ms); |
|
279 |
||
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
280 |
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
|
281 |
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
|
282 |
|
1374 | 283 |
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
|
284 |
|
1374 | 285 |
size_t _pending_cards; |
286 |
||
287 |
public: |
|
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11169
diff
changeset
|
288 |
// Accessors |
1374 | 289 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
290 |
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
|
291 |
hr->set_eden(); |
1374 | 292 |
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
|
293 |
hr->set_young_index_in_cset(young_index_in_cset); |
1374 | 294 |
} |
295 |
||
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
296 |
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
|
297 |
assert(hr->is_survivor(), "pre-condition"); |
1374 | 298 |
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
|
299 |
hr->set_young_index_in_cset(young_index_in_cset); |
1374 | 300 |
} |
301 |
||
302 |
#ifndef PRODUCT |
|
303 |
bool verify_young_ages(); |
|
304 |
#endif // PRODUCT |
|
305 |
||
306 |
double get_new_prediction(TruncatedSeq* seq) { |
|
307 |
return MAX2(seq->davg() + sigma() * seq->dsd(), |
|
308 |
seq->davg() * confidence_factor(seq->num())); |
|
309 |
} |
|
310 |
||
311 |
void record_max_rs_lengths(size_t rs_lengths) { |
|
312 |
_max_rs_lengths = rs_lengths; |
|
313 |
} |
|
314 |
||
315 |
size_t predict_rs_length_diff() { |
|
316 |
return (size_t) get_new_prediction(_rs_length_diff_seq); |
|
317 |
} |
|
318 |
||
319 |
double predict_alloc_rate_ms() { |
|
320 |
return get_new_prediction(_alloc_rate_ms_seq); |
|
321 |
} |
|
322 |
||
323 |
double predict_cost_per_card_ms() { |
|
324 |
return get_new_prediction(_cost_per_card_ms_seq); |
|
325 |
} |
|
326 |
||
327 |
double predict_rs_update_time_ms(size_t pending_cards) { |
|
328 |
return (double) pending_cards * predict_cost_per_card_ms(); |
|
329 |
} |
|
330 |
||
11249 | 331 |
double predict_young_cards_per_entry_ratio() { |
332 |
return get_new_prediction(_young_cards_per_entry_ratio_seq); |
|
1374 | 333 |
} |
334 |
||
11249 | 335 |
double predict_mixed_cards_per_entry_ratio() { |
336 |
if (_mixed_cards_per_entry_ratio_seq->num() < 2) { |
|
337 |
return predict_young_cards_per_entry_ratio(); |
|
338 |
} else { |
|
339 |
return get_new_prediction(_mixed_cards_per_entry_ratio_seq); |
|
340 |
} |
|
1374 | 341 |
} |
342 |
||
343 |
size_t predict_young_card_num(size_t rs_length) { |
|
344 |
return (size_t) ((double) rs_length * |
|
11249 | 345 |
predict_young_cards_per_entry_ratio()); |
1374 | 346 |
} |
347 |
||
348 |
size_t predict_non_young_card_num(size_t rs_length) { |
|
349 |
return (size_t) ((double) rs_length * |
|
11249 | 350 |
predict_mixed_cards_per_entry_ratio()); |
1374 | 351 |
} |
352 |
||
353 |
double predict_rs_scan_time_ms(size_t card_num) { |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
354 |
if (collector_state()->gcs_are_young()) { |
1374 | 355 |
return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
11249 | 356 |
} else { |
357 |
return predict_mixed_rs_scan_time_ms(card_num); |
|
358 |
} |
|
1374 | 359 |
} |
360 |
||
11249 | 361 |
double predict_mixed_rs_scan_time_ms(size_t card_num) { |
362 |
if (_mixed_cost_per_entry_ms_seq->num() < 3) { |
|
1374 | 363 |
return (double) card_num * get_new_prediction(_cost_per_entry_ms_seq); |
11249 | 364 |
} else { |
365 |
return (double) (card_num * |
|
366 |
get_new_prediction(_mixed_cost_per_entry_ms_seq)); |
|
367 |
} |
|
1374 | 368 |
} |
369 |
||
370 |
double predict_object_copy_time_ms_during_cm(size_t bytes_to_copy) { |
|
11249 | 371 |
if (_cost_per_byte_ms_during_cm_seq->num() < 3) { |
372 |
return (1.1 * (double) bytes_to_copy) * |
|
373 |
get_new_prediction(_cost_per_byte_ms_seq); |
|
374 |
} else { |
|
1374 | 375 |
return (double) bytes_to_copy * |
11249 | 376 |
get_new_prediction(_cost_per_byte_ms_during_cm_seq); |
377 |
} |
|
1374 | 378 |
} |
379 |
||
380 |
double predict_object_copy_time_ms(size_t bytes_to_copy) { |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
381 |
if (collector_state()->during_concurrent_mark()) { |
1374 | 382 |
return predict_object_copy_time_ms_during_cm(bytes_to_copy); |
11249 | 383 |
} else { |
1374 | 384 |
return (double) bytes_to_copy * |
11249 | 385 |
get_new_prediction(_cost_per_byte_ms_seq); |
386 |
} |
|
1374 | 387 |
} |
388 |
||
389 |
double predict_constant_other_time_ms() { |
|
390 |
return get_new_prediction(_constant_other_time_ms_seq); |
|
391 |
} |
|
392 |
||
393 |
double predict_young_other_time_ms(size_t young_num) { |
|
11249 | 394 |
return (double) young_num * |
395 |
get_new_prediction(_young_other_cost_per_region_ms_seq); |
|
1374 | 396 |
} |
397 |
||
398 |
double predict_non_young_other_time_ms(size_t non_young_num) { |
|
11249 | 399 |
return (double) non_young_num * |
400 |
get_new_prediction(_non_young_other_cost_per_region_ms_seq); |
|
1374 | 401 |
} |
402 |
||
403 |
double predict_base_elapsed_time_ms(size_t pending_cards); |
|
404 |
double predict_base_elapsed_time_ms(size_t pending_cards, |
|
405 |
size_t scanned_cards); |
|
406 |
size_t predict_bytes_to_copy(HeapRegion* hr); |
|
13482 | 407 |
double predict_region_elapsed_time_ms(HeapRegion* hr, bool for_young_gc); |
1374 | 408 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
409 |
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
|
410 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
411 |
uint cset_region_length() { return young_cset_region_length() + |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
412 |
old_cset_region_length(); } |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
413 |
uint young_cset_region_length() { return eden_cset_region_length() + |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
414 |
survivor_cset_region_length(); } |
1374 | 415 |
|
2009 | 416 |
double predict_survivor_regions_evac_time(); |
417 |
||
1374 | 418 |
void cset_regions_freed() { |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
419 |
bool propagate = collector_state()->should_propagate(); |
1374 | 420 |
_short_lived_surv_rate_group->all_surviving_words_recorded(propagate); |
421 |
_survivor_surv_rate_group->all_surviving_words_recorded(propagate); |
|
422 |
// also call it on any more surv rate groups |
|
423 |
} |
|
424 |
||
425 |
G1MMUTracker* mmu_tracker() { |
|
426 |
return _mmu_tracker; |
|
427 |
} |
|
428 |
||
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
429 |
double max_pause_time_ms() { |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
430 |
return _mmu_tracker->max_gc_time() * 1000.0; |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
431 |
} |
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
432 |
|
1374 | 433 |
double predict_remark_time_ms() { |
434 |
return get_new_prediction(_concurrent_mark_remark_times_ms); |
|
435 |
} |
|
436 |
||
437 |
double predict_cleanup_time_ms() { |
|
438 |
return get_new_prediction(_concurrent_mark_cleanup_times_ms); |
|
439 |
} |
|
440 |
||
441 |
// Returns an estimate of the survival rate of the region at yg-age |
|
442 |
// "yg_age". |
|
2009 | 443 |
double predict_yg_surv_rate(int age, SurvRateGroup* surv_rate_group) { |
444 |
TruncatedSeq* seq = surv_rate_group->get_seq(age); |
|
1374 | 445 |
if (seq->num() == 0) |
446 |
gclog_or_tty->print("BARF! age is %d", age); |
|
447 |
guarantee( seq->num() > 0, "invariant" ); |
|
448 |
double pred = get_new_prediction(seq); |
|
449 |
if (pred > 1.0) |
|
450 |
pred = 1.0; |
|
451 |
return pred; |
|
452 |
} |
|
453 |
||
2009 | 454 |
double predict_yg_surv_rate(int age) { |
455 |
return predict_yg_surv_rate(age, _short_lived_surv_rate_group); |
|
456 |
} |
|
457 |
||
1374 | 458 |
double accum_yg_surv_rate_pred(int age) { |
459 |
return _short_lived_surv_rate_group->accum_surv_rate_pred(age); |
|
460 |
} |
|
461 |
||
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
462 |
private: |
1374 | 463 |
// Statistics kept per GC stoppage, pause or full. |
464 |
TruncatedSeq* _recent_prev_end_times_for_all_gcs_sec; |
|
465 |
||
466 |
// Add a new GC of the given duration and end time to the record. |
|
467 |
void update_recent_gc_times(double end_time_sec, double elapsed_ms); |
|
468 |
||
469 |
// 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
|
470 |
// 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
|
471 |
// set at the start of the pause. |
1374 | 472 |
HeapRegion* _collection_set; |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
473 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
474 |
// 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
|
475 |
// the incrementally built collection set at the start of an evacuation |
13482 | 476 |
// pause, and incremented in finalize_cset() when adding old regions |
477 |
// (if any) to the collection set. |
|
1374 | 478 |
size_t _collection_set_bytes_used_before; |
479 |
||
13482 | 480 |
// The number of bytes copied during the GC. |
481 |
size_t _bytes_copied_during_gc; |
|
482 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
483 |
// 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
|
484 |
// 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
|
485 |
// 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
|
486 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
487 |
enum CSetBuildType { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
488 |
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
|
489 |
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
|
490 |
}; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
491 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
492 |
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
|
493 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
494 |
// 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
|
495 |
HeapRegion* _inc_cset_head; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
496 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
497 |
// 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
|
498 |
HeapRegion* _inc_cset_tail; |
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 |
// 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
|
501 |
// 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
|
502 |
// an evacuation pause. |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
503 |
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
|
504 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
505 |
// 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
|
506 |
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
|
507 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
508 |
// 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
|
509 |
// 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
|
510 |
// 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
|
511 |
// 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
|
512 |
// 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
|
513 |
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
|
514 |
|
22551 | 515 |
// 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
|
516 |
// region RSets and needs to update _inc_cset_recorded_rs_lengths as |
22551 | 517 |
// 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
|
518 |
// 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
|
519 |
// _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
|
520 |
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
|
521 |
|
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
522 |
// 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
|
523 |
// 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
|
524 |
// 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
|
525 |
// MT-safety assumptions. |
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
526 |
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
|
527 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
528 |
// 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
|
529 |
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
|
530 |
|
1374 | 531 |
// Stash a pointer to the g1 heap. |
532 |
G1CollectedHeap* _g1; |
|
533 |
||
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
534 |
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
|
535 |
|
1374 | 536 |
// The ratio of gc time to elapsed time, computed over recent pauses. |
537 |
double _recent_avg_pause_time_ratio; |
|
538 |
||
539 |
double recent_avg_pause_time_ratio() { |
|
540 |
return _recent_avg_pause_time_ratio; |
|
541 |
} |
|
542 |
||
543 |
// This set of variables tracks the collector efficiency, in order to |
|
544 |
// determine whether we should initiate a new marking. |
|
545 |
double _cur_mark_stop_world_time_ms; |
|
546 |
double _mark_remark_start_sec; |
|
547 |
double _mark_cleanup_start_sec; |
|
548 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
549 |
// 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
|
550 |
// 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
|
551 |
// 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
|
552 |
// 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
|
553 |
// 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
|
554 |
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
|
555 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
556 |
// 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
|
557 |
// 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
|
558 |
// to the user's inputs. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
559 |
uint calculate_young_list_desired_min_length(uint base_min_length); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
560 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
561 |
// 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
|
562 |
// 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
|
563 |
// to the user's inputs. |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
564 |
uint calculate_young_list_desired_max_length(); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
565 |
|
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
566 |
// 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
|
567 |
// 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
|
568 |
// represent the prediction of how large the young RSet lengths will |
22551 | 569 |
// 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
|
570 |
// 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
|
571 |
// 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
|
572 |
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
|
573 |
uint base_min_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
574 |
uint desired_min_length, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
575 |
uint desired_max_length); |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
576 |
|
27626
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
26696
diff
changeset
|
577 |
// 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
|
578 |
// concurrent mark cleanup. |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
26696
diff
changeset
|
579 |
uint calculate_parallel_work_chunk_size(uint n_workers, uint n_regions); |
5dad25da637c
8054491: Remove wrong assert and refactor code in G1CollectorPolicy::record_concurrent_mark_end
mlarsson
parents:
26696
diff
changeset
|
580 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
581 |
// 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
|
582 |
// 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
|
583 |
// 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
|
584 |
// 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
|
585 |
// calculate_young_list_target_length(). |
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
586 |
bool predict_will_fit(uint young_length, double base_time_ms, |
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
587 |
uint base_free_regions, double target_pause_time_ms); |
1374 | 588 |
|
15861
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
589 |
// 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
|
590 |
// during a mixed GC. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
591 |
uint calc_min_old_cset_length(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
592 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
593 |
// 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
|
594 |
// during a mixed GC. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
595 |
uint calc_max_old_cset_length(); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
596 |
|
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
597 |
// 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
|
598 |
// as a percentage of the current heap capacity. |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
599 |
double reclaimable_bytes_perc(size_t reclaimable_bytes); |
974c3ccaa5d2
8007036: G1: Too many old regions added to last mixed GC
johnc
parents:
15089
diff
changeset
|
600 |
|
1374 | 601 |
public: |
602 |
||
603 |
G1CollectorPolicy(); |
|
604 |
||
605 |
virtual G1CollectorPolicy* as_g1_policy() { return this; } |
|
606 |
||
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
607 |
G1CollectorState* collector_state(); |
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
30874
diff
changeset
|
608 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
12781
diff
changeset
|
609 |
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
|
610 |
|
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
611 |
// 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
|
612 |
// 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
|
613 |
// 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
|
614 |
void revise_young_list_target_length_if_necessary(); |
1374 | 615 |
|
10529
9d5bbffbb322
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
10528
diff
changeset
|
616 |
// 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
|
617 |
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
|
618 |
|
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
619 |
void init(); |
1374 | 620 |
|
2009 | 621 |
// Create jstat counters for the policy. |
622 |
virtual void initialize_gc_policy_counters(); |
|
623 |
||
1374 | 624 |
virtual HeapWord* mem_allocate_work(size_t size, |
625 |
bool is_tlab, |
|
626 |
bool* gc_overhead_limit_was_exceeded); |
|
627 |
||
628 |
// This method controls how a collector handles one or more |
|
629 |
// of its generations being fully allocated. |
|
630 |
virtual HeapWord* satisfy_failed_allocation(size_t size, |
|
631 |
bool is_tlab); |
|
632 |
||
11581
b1afc51ad34e
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
11576
diff
changeset
|
633 |
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
|
634 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
635 |
// 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
|
636 |
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
|
637 |
void record_collection_pause_end(double pause_time_ms, size_t cards_scanned); |
1374 | 638 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
639 |
// 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
|
640 |
void record_full_collection_start(); |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
641 |
void record_full_collection_end(); |
1374 | 642 |
|
643 |
// 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
|
644 |
void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms); |
1374 | 645 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
646 |
// Record start and end of remark. |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
647 |
void record_concurrent_mark_remark_start(); |
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
648 |
void record_concurrent_mark_remark_end(); |
1374 | 649 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
650 |
// Record start, end, and completion of cleanup. |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
651 |
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
|
652 |
void record_concurrent_mark_cleanup_end(); |
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
653 |
void record_concurrent_mark_cleanup_completed(); |
1374 | 654 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
655 |
// 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
|
656 |
// 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
|
657 |
void record_heap_size_info_at_start(bool full); |
1374 | 658 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
659 |
// 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
|
660 |
|
984c5c379c6a
8076076: Move SharedHeap::print_size_transition() into G1 code
brutisso
parents:
28213
diff
changeset
|
661 |
void print_heap_transition(size_t bytes_before); |
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
662 |
void print_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
|
663 |
void print_detailed_heap_transition(bool full = false); |
1374 | 664 |
|
16993
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
665 |
void record_stop_world_start(); |
c9fd6b7ef40e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
15861
diff
changeset
|
666 |
void record_concurrent_pause(); |
1374 | 667 |
|
10243
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
668 |
// 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
|
669 |
// 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
|
670 |
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
|
671 |
_bytes_copied_during_gc += bytes; |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
672 |
} |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
673 |
|
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
674 |
// The amount of space we copied during a GC. |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
675 |
size_t bytes_copied_during_gc() { |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
676 |
return _bytes_copied_during_gc; |
d00a21009f1f
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
10236
diff
changeset
|
677 |
} |
1374 | 678 |
|
32591
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
679 |
size_t collection_set_bytes_used_before() const { |
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
680 |
return _collection_set_bytes_used_before; |
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
681 |
} |
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
682 |
|
12236
51d6463cfd9d
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
11756
diff
changeset
|
683 |
// Determine whether there are candidate regions so that the |
51d6463cfd9d
7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents:
11756
diff
changeset
|
684 |
// 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
|
685 |
// 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
|
686 |
bool next_gc_should_be_mixed(const char* true_action_str, |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
687 |
const char* false_action_str); |
28b6fe22e43d
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
11584
diff
changeset
|
688 |
|
1374 | 689 |
// Choose a new collection set. Marks the chosen regions as being |
690 |
// "in_collection_set", and links them together. The head and number of |
|
691 |
// the collection set are available via access methods. |
|
32591
b4acfa743bb6
8134504: Remove usage of EvacuationInfo from G1CollectorPolicy
ehelin
parents:
32378
diff
changeset
|
692 |
void finalize_cset(double target_pause_time_ms); |
1374 | 693 |
|
694 |
// The head of the list (via "next_in_collection_set()") representing the |
|
695 |
// current collection set. |
|
696 |
HeapRegion* collection_set() { return _collection_set; } |
|
697 |
||
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
698 |
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
|
699 |
|
11169
0cfe4d79060c
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
10770
diff
changeset
|
700 |
// 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
|
701 |
void add_old_region_to_cset(HeapRegion* hr); |
1374 | 702 |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
703 |
// Incremental CSet Support |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
704 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
705 |
// 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
|
706 |
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
|
707 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
708 |
// 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
|
709 |
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
|
710 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
711 |
// 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
|
712 |
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
|
713 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
714 |
// 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
|
715 |
// before we can use them. |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
716 |
void finalize_incremental_cset_building(); |
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
717 |
|
5350
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
718 |
void clear_incremental_cset() { |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
719 |
_inc_cset_head = NULL; |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
720 |
_inc_cset_tail = NULL; |
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 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
723 |
// 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
|
724 |
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
|
725 |
|
11395
33260c27554b
7119027: G1: use atomics to update RS length / predict time of inc CSet
tonyp
parents:
11249
diff
changeset
|
726 |
// 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
|
727 |
// 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
|
728 |
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
|
729 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
730 |
// 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
|
731 |
// 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
|
732 |
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
|
733 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
734 |
private: |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
735 |
// 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
|
736 |
// (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
|
737 |
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
|
738 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
739 |
public: |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
740 |
// 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
|
741 |
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
|
742 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
743 |
// 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
|
744 |
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
|
745 |
|
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
746 |
#ifndef PRODUCT |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
747 |
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
|
748 |
#endif // !PRODUCT |
cccf0925702e
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
5243
diff
changeset
|
749 |
|
6058
9c9aec6ab47d
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
5891
diff
changeset
|
750 |
// 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
|
751 |
// 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
|
752 |
// 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
|
753 |
// 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
|
754 |
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
|
755 |
|
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
756 |
// 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
|
757 |
// 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
|
758 |
// 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
|
759 |
// 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
|
760 |
// 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
|
761 |
// the initial-mark work and start a marking cycle. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5240
diff
changeset
|
762 |
void decide_on_conc_mark_initiation(); |
1374 | 763 |
|
764 |
// If an expansion would be appropriate, because recent GC overhead had |
|
765 |
// exceeded the desired limit, return an amount to expand by. |
|
27892
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
766 |
virtual size_t expansion_amount(); |
1374 | 767 |
|
768 |
// Print tracing information. |
|
769 |
void print_tracing_info() const; |
|
770 |
||
771 |
// Print stats on young survival ratio |
|
772 |
void print_yg_surv_rate_info() const; |
|
773 |
||
2009 | 774 |
void finished_recalculating_age_indexes(bool is_survivors) { |
775 |
if (is_survivors) { |
|
776 |
_survivor_surv_rate_group->finished_recalculating_age_indexes(); |
|
777 |
} else { |
|
778 |
_short_lived_surv_rate_group->finished_recalculating_age_indexes(); |
|
779 |
} |
|
1374 | 780 |
// do that for any other surv rate groups |
781 |
} |
|
782 |
||
22552 | 783 |
size_t young_list_target_length() const { return _young_list_target_length; } |
784 |
||
27892
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
785 |
bool is_young_list_full(); |
7416
cfe3bfab7d48
6994056: G1: when GC locker is active, extend the Eden instead of allocating into the old gen
tonyp
parents:
7398
diff
changeset
|
786 |
|
27892
06a143c836ad
8065305: Make it possible to extend the G1CollectorPolicy
jwilhelm
parents:
27626
diff
changeset
|
787 |
bool can_expand_young_list(); |
7398 | 788 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
789 |
uint young_list_max_length() { |
10671
431ff8629f97
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
10670
diff
changeset
|
790 |
return _young_list_max_length; |
431ff8629f97
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
10670
diff
changeset
|
791 |
} |
431ff8629f97
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
10670
diff
changeset
|
792 |
|
1374 | 793 |
bool adaptive_young_list_length() { |
11397
7dc5c8f572b0
7113021: G1: automatically enable young gen size auto-tuning when -Xms==-Xmx
brutisso
parents:
11395
diff
changeset
|
794 |
return _young_gen_sizer->adaptive_young_list_length(); |
1374 | 795 |
} |
796 |
||
10746
96f50959f650
7088680: G1: Cleanup in the G1CollectorPolicy class
tonyp
parents:
10671
diff
changeset
|
797 |
private: |
1374 | 798 |
// |
799 |
// Survivor regions policy. |
|
800 |
// |
|
801 |
||
802 |
// Current tenuring threshold, set to 0 if the collector reaches the |
|
13925 | 803 |
// maximum amount of survivors regions. |
804 |
uint _tenuring_threshold; |
|
1374 | 805 |
|
2009 | 806 |
// 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
|
807 |
uint _max_survivor_regions; |
2009 | 808 |
|
9987
6e2b9796996f
7032531: G1: enhance GC logging to include more accurate eden / survivor size transitions
tonyp
parents:
8925
diff
changeset
|
809 |
// 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
|
810 |
// 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
|
811 |
// 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
|
812 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
813 |
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
|
814 |
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
|
815 |
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
|
816 |
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
|
817 |
|
4d281f3a57bf
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
16993
diff
changeset
|
818 |
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
|
819 |
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
|
820 |
|
13925 | 821 |
// 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
|
822 |
uint _recorded_survivor_regions; |
2009 | 823 |
// List of survivor regions. |
824 |
HeapRegion* _recorded_survivor_head; |
|
825 |
HeapRegion* _recorded_survivor_tail; |
|
826 |
||
827 |
ageTable _survivors_age_table; |
|
828 |
||
1374 | 829 |
public: |
18025 | 830 |
uint tenuring_threshold() const { return _tenuring_threshold; } |
1374 | 831 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
832 |
static const uint REGIONS_UNLIMITED = (uint) -1; |
2009 | 833 |
|
28213
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
834 |
uint max_regions(InCSetState dest) { |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
835 |
switch (dest.value()) { |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
836 |
case InCSetState::Young: |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
837 |
return _max_survivor_regions; |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
838 |
case InCSetState::Old: |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
839 |
return REGIONS_UNLIMITED; |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
840 |
default: |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
841 |
assert(false, err_msg("Unknown dest state: " CSETSTATE_FORMAT, dest.value())); |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
842 |
break; |
1374 | 843 |
} |
28213
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
844 |
// keep some compilers happy |
b0bf57cd1e9d
8060025: Object copy time regressions after JDK-8031323 and JDK-8057536
tschatzl
parents:
27892
diff
changeset
|
845 |
return 0; |
1374 | 846 |
} |
847 |
||
848 |
void note_start_adding_survivor_regions() { |
|
849 |
_survivor_surv_rate_group->start_adding_regions(); |
|
850 |
} |
|
851 |
||
852 |
void note_stop_adding_survivor_regions() { |
|
853 |
_survivor_surv_rate_group->stop_adding_regions(); |
|
854 |
} |
|
2009 | 855 |
|
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
856 |
void record_survivor_regions(uint regions, |
2009 | 857 |
HeapRegion* head, |
858 |
HeapRegion* tail) { |
|
859 |
_recorded_survivor_regions = regions; |
|
860 |
_recorded_survivor_head = head; |
|
861 |
_recorded_survivor_tail = tail; |
|
862 |
} |
|
863 |
||
12381
1438e0fbfa27
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
12272
diff
changeset
|
864 |
uint recorded_survivor_regions() { |
3191
dd3cc90b9951
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
2881
diff
changeset
|
865 |
return _recorded_survivor_regions; |
dd3cc90b9951
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
2881
diff
changeset
|
866 |
} |
dd3cc90b9951
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
2881
diff
changeset
|
867 |
|
32736
755024a84282
8135152: Create a G1ParScanThreadStateSet class for managing G1 GC per thread states
mgerdin
parents:
32603
diff
changeset
|
868 |
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
|
869 |
_survivors_age_table.merge(age_table); |
2009 | 870 |
} |
871 |
||
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
872 |
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
|
873 |
|
2009 | 874 |
// Calculates survivor space parameters. |
10528
06fab03478df
7084509: G1: fix inconsistencies and mistakes in the young list target length calculations
tonyp
parents:
10523
diff
changeset
|
875 |
void update_survivors_policy(); |
2009 | 876 |
|
21561
c619b1cb4554
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
21560
diff
changeset
|
877 |
virtual void post_heap_initialize(); |
1374 | 878 |
}; |
879 |
||
880 |
// This should move to some place more general... |
|
881 |
||
882 |
// If we have "n" measurements, and we've kept track of their "sum" and the |
|
883 |
// "sum_of_squares" of the measurements, this returns the variance of the |
|
884 |
// sequence. |
|
885 |
inline double variance(int n, double sum_of_squares, double sum) { |
|
886 |
double n_d = (double)n; |
|
887 |
double avg = sum/n_d; |
|
888 |
return (sum_of_squares - 2.0 * avg * sum + n_d * avg * avg) / n_d; |
|
889 |
} |
|
890 |
||
30764 | 891 |
#endif // SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP |