annotate src/share/vm/memory/collectorPolicy.cpp @ 452:00b023ae2d78

6722113: CMS: Incorrect overflow handling during precleaning of Reference lists Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery. Reviewed-by: apetrusenko, jcoomes
author ysr
date Thu, 20 Nov 2008 12:27:41 -0800
parents 1ee8caae33af
children 473cce303f13
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
196
d1605aabd0a1 6719955: Update copyright year
xdono
parents: 13
diff changeset
2 * Copyright 2001-2008 Sun Microsystems, Inc. All Rights Reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 # include "incls/_precompiled.incl"
a61af66fc99e Initial load
duke
parents:
diff changeset
26 # include "incls/_collectorPolicy.cpp.incl"
a61af66fc99e Initial load
duke
parents:
diff changeset
27
a61af66fc99e Initial load
duke
parents:
diff changeset
28 // CollectorPolicy methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
29
a61af66fc99e Initial load
duke
parents:
diff changeset
30 void CollectorPolicy::initialize_flags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
31 if (PermSize > MaxPermSize) {
a61af66fc99e Initial load
duke
parents:
diff changeset
32 MaxPermSize = PermSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
33 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
34 PermSize = MAX2(min_alignment(), align_size_down_(PermSize, min_alignment()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
35 MaxPermSize = align_size_up(MaxPermSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
36
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
37 MinPermHeapExpansion = MAX2(min_alignment(), align_size_down_(MinPermHeapExpansion, min_alignment()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
38 MaxPermHeapExpansion = MAX2(min_alignment(), align_size_down_(MaxPermHeapExpansion, min_alignment()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
39
a61af66fc99e Initial load
duke
parents:
diff changeset
40 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
41
a61af66fc99e Initial load
duke
parents:
diff changeset
42 SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
43 SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
44 SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
45
a61af66fc99e Initial load
duke
parents:
diff changeset
46 assert(PermSize % min_alignment() == 0, "permanent space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
47 assert(MaxPermSize % max_alignment() == 0, "maximum permanent space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
48 assert(SharedReadOnlySize % max_alignment() == 0, "read-only space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
49 assert(SharedReadWriteSize % max_alignment() == 0, "read-write space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
50 assert(SharedMiscDataSize % max_alignment() == 0, "misc-data space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
51 if (PermSize < M) {
a61af66fc99e Initial load
duke
parents:
diff changeset
52 vm_exit_during_initialization("Too small initial permanent heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
53 }
a61af66fc99e Initial load
duke
parents:
diff changeset
54 }
a61af66fc99e Initial load
duke
parents:
diff changeset
55
a61af66fc99e Initial load
duke
parents:
diff changeset
56 void CollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
57 // User inputs from -mx and ms are aligned
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
58 set_initial_heap_byte_size(Arguments::initial_heap_size());
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
59 if (initial_heap_byte_size() == 0) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
60 set_initial_heap_byte_size(NewSize + OldSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
61 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
62 set_initial_heap_byte_size(align_size_up(_initial_heap_byte_size,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
63 min_alignment()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
64
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
65 set_min_heap_byte_size(Arguments::min_heap_size());
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
66 if (min_heap_byte_size() == 0) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
67 set_min_heap_byte_size(NewSize + OldSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
68 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
69 set_min_heap_byte_size(align_size_up(_min_heap_byte_size,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
70 min_alignment()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
71
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
72 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
73
a61af66fc99e Initial load
duke
parents:
diff changeset
74 // Check heap parameter properties
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
75 if (initial_heap_byte_size() < M) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
76 vm_exit_during_initialization("Too small initial heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
77 }
a61af66fc99e Initial load
duke
parents:
diff changeset
78 // Check heap parameter properties
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
79 if (min_heap_byte_size() < M) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
80 vm_exit_during_initialization("Too small minimum heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
81 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
82 if (initial_heap_byte_size() <= NewSize) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
83 // make sure there is at least some room in old space
a61af66fc99e Initial load
duke
parents:
diff changeset
84 vm_exit_during_initialization("Too small initial heap for new size specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
85 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
86 if (max_heap_byte_size() < min_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
87 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
88 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
89 if (initial_heap_byte_size() < min_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
90 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
91 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
92 if (max_heap_byte_size() < initial_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
93 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
94 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
95
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
96 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
97 gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
98 SIZE_FORMAT " Maximum heap " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
99 min_heap_byte_size(), initial_heap_byte_size(), max_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
100 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
101 }
a61af66fc99e Initial load
duke
parents:
diff changeset
102
a61af66fc99e Initial load
duke
parents:
diff changeset
103 void CollectorPolicy::initialize_perm_generation(PermGen::Name pgnm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
104 _permanent_generation =
a61af66fc99e Initial load
duke
parents:
diff changeset
105 new PermanentGenerationSpec(pgnm, PermSize, MaxPermSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
106 SharedReadOnlySize,
a61af66fc99e Initial load
duke
parents:
diff changeset
107 SharedReadWriteSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
108 SharedMiscDataSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
109 SharedMiscCodeSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
110 if (_permanent_generation == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
111 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load
duke
parents:
diff changeset
112 }
a61af66fc99e Initial load
duke
parents:
diff changeset
113 }
a61af66fc99e Initial load
duke
parents:
diff changeset
114
a61af66fc99e Initial load
duke
parents:
diff changeset
115
a61af66fc99e Initial load
duke
parents:
diff changeset
116 GenRemSet* CollectorPolicy::create_rem_set(MemRegion whole_heap,
a61af66fc99e Initial load
duke
parents:
diff changeset
117 int max_covered_regions) {
a61af66fc99e Initial load
duke
parents:
diff changeset
118 switch (rem_set_name()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
119 case GenRemSet::CardTable: {
a61af66fc99e Initial load
duke
parents:
diff changeset
120 CardTableRS* res = new CardTableRS(whole_heap, max_covered_regions);
a61af66fc99e Initial load
duke
parents:
diff changeset
121 return res;
a61af66fc99e Initial load
duke
parents:
diff changeset
122 }
a61af66fc99e Initial load
duke
parents:
diff changeset
123 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
124 guarantee(false, "unrecognized GenRemSet::Name");
a61af66fc99e Initial load
duke
parents:
diff changeset
125 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
126 }
a61af66fc99e Initial load
duke
parents:
diff changeset
127 }
a61af66fc99e Initial load
duke
parents:
diff changeset
128
a61af66fc99e Initial load
duke
parents:
diff changeset
129 // GenCollectorPolicy methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
130
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
131 size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
132 size_t x = base_size / (NewRatio+1);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
133 size_t new_gen_size = x > min_alignment() ?
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
134 align_size_down(x, min_alignment()) :
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
135 min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
136 return new_gen_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
137 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
138
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
139 size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
140 size_t maximum_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
141 size_t alignment = min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
142 size_t max_minus = maximum_size - alignment;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
143 return desired_size < max_minus ? desired_size : max_minus;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
144 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
145
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
146
0
a61af66fc99e Initial load
duke
parents:
diff changeset
147 void GenCollectorPolicy::initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
148 size_t init_promo_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
149 size_t init_survivor_size) {
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
150 const double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
151 _size_policy = new AdaptiveSizePolicy(init_eden_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
152 init_promo_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
153 init_survivor_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
154 max_gc_minor_pause_sec,
a61af66fc99e Initial load
duke
parents:
diff changeset
155 GCTimeRatio);
a61af66fc99e Initial load
duke
parents:
diff changeset
156 }
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 size_t GenCollectorPolicy::compute_max_alignment() {
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // The card marking array and the offset arrays for old generations are
a61af66fc99e Initial load
duke
parents:
diff changeset
160 // committed in os pages as well. Make sure they are entirely full (to
a61af66fc99e Initial load
duke
parents:
diff changeset
161 // avoid partial page problems), e.g. if 512 bytes heap corresponds to 1
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // byte entry and the os page size is 4096, the maximum heap size should
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // be 512*4096 = 2MB aligned.
a61af66fc99e Initial load
duke
parents:
diff changeset
164 size_t alignment = GenRemSet::max_alignment_constraint(rem_set_name());
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // Parallel GC does its own alignment of the generations to avoid requiring a
a61af66fc99e Initial load
duke
parents:
diff changeset
167 // large page (256M on some platforms) for the permanent generation. The
a61af66fc99e Initial load
duke
parents:
diff changeset
168 // other collectors should also be updated to do their own alignment and then
a61af66fc99e Initial load
duke
parents:
diff changeset
169 // this use of lcm() should be removed.
a61af66fc99e Initial load
duke
parents:
diff changeset
170 if (UseLargePages && !UseParallelGC) {
a61af66fc99e Initial load
duke
parents:
diff changeset
171 // in presence of large pages we have to make sure that our
a61af66fc99e Initial load
duke
parents:
diff changeset
172 // alignment is large page aware
a61af66fc99e Initial load
duke
parents:
diff changeset
173 alignment = lcm(os::large_page_size(), alignment);
a61af66fc99e Initial load
duke
parents:
diff changeset
174 }
a61af66fc99e Initial load
duke
parents:
diff changeset
175
a61af66fc99e Initial load
duke
parents:
diff changeset
176 return alignment;
a61af66fc99e Initial load
duke
parents:
diff changeset
177 }
a61af66fc99e Initial load
duke
parents:
diff changeset
178
a61af66fc99e Initial load
duke
parents:
diff changeset
179 void GenCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
180 // All sizes must be multiples of the generation granularity.
a61af66fc99e Initial load
duke
parents:
diff changeset
181 set_min_alignment((uintx) Generation::GenGrain);
a61af66fc99e Initial load
duke
parents:
diff changeset
182 set_max_alignment(compute_max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
183 assert(max_alignment() >= min_alignment() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
184 max_alignment() % min_alignment() == 0,
a61af66fc99e Initial load
duke
parents:
diff changeset
185 "invalid alignment constraints");
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 CollectorPolicy::initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
188
a61af66fc99e Initial load
duke
parents:
diff changeset
189 // All generational heaps have a youngest gen; handle those flags here.
a61af66fc99e Initial load
duke
parents:
diff changeset
190
a61af66fc99e Initial load
duke
parents:
diff changeset
191 // Adjust max size parameters
a61af66fc99e Initial load
duke
parents:
diff changeset
192 if (NewSize > MaxNewSize) {
a61af66fc99e Initial load
duke
parents:
diff changeset
193 MaxNewSize = NewSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
194 }
a61af66fc99e Initial load
duke
parents:
diff changeset
195 NewSize = align_size_down(NewSize, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
196 MaxNewSize = align_size_down(MaxNewSize, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 // Check validity of heap flags
a61af66fc99e Initial load
duke
parents:
diff changeset
199 assert(NewSize % min_alignment() == 0, "eden space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
200 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202 if (NewSize < 3*min_alignment()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
203 // make sure there room for eden and two survivor spaces
a61af66fc99e Initial load
duke
parents:
diff changeset
204 vm_exit_during_initialization("Too small new size specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
205 }
a61af66fc99e Initial load
duke
parents:
diff changeset
206 if (SurvivorRatio < 1 || NewRatio < 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
207 vm_exit_during_initialization("Invalid heap ratio specified");
a61af66fc99e Initial load
duke
parents:
diff changeset
208 }
a61af66fc99e Initial load
duke
parents:
diff changeset
209 }
a61af66fc99e Initial load
duke
parents:
diff changeset
210
a61af66fc99e Initial load
duke
parents:
diff changeset
211 void TwoGenerationCollectorPolicy::initialize_flags() {
a61af66fc99e Initial load
duke
parents:
diff changeset
212 GenCollectorPolicy::initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
213
a61af66fc99e Initial load
duke
parents:
diff changeset
214 OldSize = align_size_down(OldSize, min_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
215 if (NewSize + OldSize > MaxHeapSize) {
a61af66fc99e Initial load
duke
parents:
diff changeset
216 MaxHeapSize = NewSize + OldSize;
a61af66fc99e Initial load
duke
parents:
diff changeset
217 }
a61af66fc99e Initial load
duke
parents:
diff changeset
218 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
a61af66fc99e Initial load
duke
parents:
diff changeset
219
a61af66fc99e Initial load
duke
parents:
diff changeset
220 always_do_update_barrier = UseConcMarkSweepGC;
a61af66fc99e Initial load
duke
parents:
diff changeset
221 BlockOffsetArrayUseUnallocatedBlock =
a61af66fc99e Initial load
duke
parents:
diff changeset
222 BlockOffsetArrayUseUnallocatedBlock || ParallelGCThreads > 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
223
a61af66fc99e Initial load
duke
parents:
diff changeset
224 // Check validity of heap flags
a61af66fc99e Initial load
duke
parents:
diff changeset
225 assert(OldSize % min_alignment() == 0, "old space alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
226 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment");
a61af66fc99e Initial load
duke
parents:
diff changeset
227 }
a61af66fc99e Initial load
duke
parents:
diff changeset
228
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
229 // Values set on the command line win over any ergonomically
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
230 // set command line parameters.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
231 // Ergonomic choice of parameters are done before this
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
232 // method is called. Values for command line parameters such as NewSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
233 // and MaxNewSize feed those ergonomic choices into this method.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
234 // This method makes the final generation sizings consistent with
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
235 // themselves and with overall heap sizings.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
236 // In the absence of explicitly set command line flags, policies
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
237 // such as the use of NewRatio are used to size the generation.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
238 void GenCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
239 CollectorPolicy::initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
240
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
241 // min_alignment() is used for alignment within a generation.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
242 // There is additional alignment done down stream for some
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
243 // collectors that sometimes causes unwanted rounding up of
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
244 // generations sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
245
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
246 // Determine maximum size of gen0
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
247
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
248 size_t max_new_size = 0;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
249 if (FLAG_IS_CMDLINE(MaxNewSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
250 if (MaxNewSize < min_alignment()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
251 max_new_size = min_alignment();
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
252 } else if (MaxNewSize >= max_heap_byte_size()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
253 max_new_size = align_size_down(max_heap_byte_size() - min_alignment(),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
254 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
255 warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
256 "greater than the entire heap (" SIZE_FORMAT "k). A "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
257 "new generation size of " SIZE_FORMAT "k will be used.",
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
258 MaxNewSize/K, max_heap_byte_size()/K, max_new_size/K);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
259 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
260 max_new_size = align_size_down(MaxNewSize, min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
261 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
262
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
263 // The case for FLAG_IS_ERGO(MaxNewSize) could be treated
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
264 // specially at this point to just use an ergonomically set
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
265 // MaxNewSize to set max_new_size. For cases with small
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
266 // heaps such a policy often did not work because the MaxNewSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
267 // was larger than the entire heap. The interpretation given
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
268 // to ergonomically set flags is that the flags are set
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
269 // by different collectors for their own special needs but
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
270 // are not allowed to badly shape the heap. This allows the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
271 // different collectors to decide what's best for themselves
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
272 // without having to factor in the overall heap shape. It
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
273 // can be the case in the future that the collectors would
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
274 // only make "wise" ergonomics choices and this policy could
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
275 // just accept those choices. The choices currently made are
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
276 // not always "wise".
0
a61af66fc99e Initial load
duke
parents:
diff changeset
277 } else {
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
278 max_new_size = scale_by_NewRatio_aligned(max_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
279 // Bound the maximum size by NewSize below (since it historically
0
a61af66fc99e Initial load
duke
parents:
diff changeset
280 // would have been NewSize and because the NewRatio calculation could
a61af66fc99e Initial load
duke
parents:
diff changeset
281 // yield a size that is too small) and bound it by MaxNewSize above.
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
282 // Ergonomics plays here by previously calculating the desired
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
283 // NewSize and MaxNewSize.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
284 max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
285 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
286 assert(max_new_size > 0, "All paths should set max_new_size");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
287
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
288 // Given the maximum gen0 size, determine the initial and
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
289 // minimum sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
290
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
291 if (max_heap_byte_size() == min_heap_byte_size()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
292 // The maximum and minimum heap sizes are the same so
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
293 // the generations minimum and initial must be the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
294 // same as its maximum.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
295 set_min_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
296 set_initial_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
297 set_max_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
298 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
299 size_t desired_new_size = 0;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
300 if (!FLAG_IS_DEFAULT(NewSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
301 // If NewSize is set ergonomically (for example by cms), it
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
302 // would make sense to use it. If it is used, also use it
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
303 // to set the initial size. Although there is no reason
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
304 // the minimum size and the initial size have to be the same,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
305 // the current implementation gets into trouble during the calculation
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
306 // of the tenured generation sizes if they are different.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
307 // Note that this makes the initial size and the minimum size
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
308 // generally small compared to the NewRatio calculation.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
309 _min_gen0_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
310 desired_new_size = NewSize;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
311 max_new_size = MAX2(max_new_size, NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
312 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
313 // For the case where NewSize is the default, use NewRatio
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
314 // to size the minimum and initial generation sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
315 // Use the default NewSize as the floor for these values. If
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
316 // NewRatio is overly large, the resulting sizes can be too
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
317 // small.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
318 _min_gen0_size = MAX2(scale_by_NewRatio_aligned(min_heap_byte_size()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
319 NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
320 desired_new_size =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
321 MAX2(scale_by_NewRatio_aligned(initial_heap_byte_size()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
322 NewSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
323 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
324
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
325 assert(_min_gen0_size > 0, "Sanity check");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
326 set_initial_gen0_size(desired_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
327 set_max_gen0_size(max_new_size);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
328
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
329 // At this point the desirable initial and minimum sizes have been
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
330 // determined without regard to the maximum sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
331
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
332 // Bound the sizes by the corresponding overall heap sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
333 set_min_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
334 bound_minus_alignment(_min_gen0_size, min_heap_byte_size()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
335 set_initial_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
336 bound_minus_alignment(_initial_gen0_size, initial_heap_byte_size()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
337 set_max_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
338 bound_minus_alignment(_max_gen0_size, max_heap_byte_size()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
339
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
340 // At this point all three sizes have been checked against the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
341 // maximum sizes but have not been checked for consistency
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
342 // among the three.
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
343
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
344 // Final check min <= initial <= max
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
345 set_min_gen0_size(MIN2(_min_gen0_size, _max_gen0_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
346 set_initial_gen0_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
347 MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
348 set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
349 }
a61af66fc99e Initial load
duke
parents:
diff changeset
350
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
351 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
352 gclog_or_tty->print_cr("Minimum gen0 " SIZE_FORMAT " Initial gen0 "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
353 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
354 min_gen0_size(), initial_gen0_size(), max_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
355 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
356 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
357
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
358 // Call this method during the sizing of the gen1 to make
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
359 // adjustments to gen0 because of gen1 sizing policy. gen0 initially has
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
360 // the most freedom in sizing because it is done before the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
361 // policy for gen1 is applied. Once gen1 policies have been applied,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
362 // there may be conflicts in the shape of the heap and this method
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
363 // is used to make the needed adjustments. The application of the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
364 // policies could be more sophisticated (iterative for example) but
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
365 // keeping it simple also seems a worthwhile goal.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
366 bool TwoGenerationCollectorPolicy::adjust_gen0_sizes(size_t* gen0_size_ptr,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
367 size_t* gen1_size_ptr,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
368 size_t heap_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
369 size_t min_gen0_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
370 bool result = false;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
371 if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
372 if (((*gen0_size_ptr + OldSize) > heap_size) &&
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
373 (heap_size - min_gen0_size) >= min_alignment()) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
374 // Adjust gen0 down to accomodate OldSize
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
375 *gen0_size_ptr = heap_size - min_gen0_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
376 *gen0_size_ptr =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
377 MAX2((uintx)align_size_down(*gen0_size_ptr, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
378 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
379 assert(*gen0_size_ptr > 0, "Min gen0 is too large");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
380 result = true;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
381 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
382 *gen1_size_ptr = heap_size - *gen0_size_ptr;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
383 *gen1_size_ptr =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
384 MAX2((uintx)align_size_down(*gen1_size_ptr, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
385 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
386 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
387 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
388 return result;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
389 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
390
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
391 // Minimum sizes of the generations may be different than
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
392 // the initial sizes. An inconsistently is permitted here
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
393 // in the total size that can be specified explicitly by
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
394 // command line specification of OldSize and NewSize and
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
395 // also a command line specification of -Xms. Issue a warning
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
396 // but allow the values to pass.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
397
a61af66fc99e Initial load
duke
parents:
diff changeset
398 void TwoGenerationCollectorPolicy::initialize_size_info() {
a61af66fc99e Initial load
duke
parents:
diff changeset
399 GenCollectorPolicy::initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
400
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
401 // At this point the minimum, initial and maximum sizes
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
402 // of the overall heap and of gen0 have been determined.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
403 // The maximum gen1 size can be determined from the maximum gen0
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
404 // and maximum heap size since not explicit flags exits
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
405 // for setting the gen1 maximum.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
406 _max_gen1_size = max_heap_byte_size() - _max_gen0_size;
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
407 _max_gen1_size =
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
408 MAX2((uintx)align_size_down(_max_gen1_size, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
409 min_alignment());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
410 // If no explicit command line flag has been set for the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
411 // gen1 size, use what is left for gen1.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
412 if (FLAG_IS_DEFAULT(OldSize) || FLAG_IS_ERGO(OldSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
413 // The user has not specified any value or ergonomics
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
414 // has chosen a value (which may or may not be consistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
415 // with the overall heap size). In either case make
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
416 // the minimum, maximum and initial sizes consistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
417 // with the gen0 sizes and the overall heap sizes.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
418 assert(min_heap_byte_size() > _min_gen0_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
419 "gen0 has an unexpected minimum size");
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
420 set_min_gen1_size(min_heap_byte_size() - min_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
421 set_min_gen1_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
422 MAX2((uintx)align_size_down(_min_gen1_size, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
423 min_alignment()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
424 set_initial_gen1_size(initial_heap_byte_size() - initial_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
425 set_initial_gen1_size(
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
426 MAX2((uintx)align_size_down(_initial_gen1_size, min_alignment()),
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
427 min_alignment()));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
428
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
429 } else {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
430 // It's been explicitly set on the command line. Use the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
431 // OldSize and then determine the consequences.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
432 set_min_gen1_size(OldSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
433 set_initial_gen1_size(OldSize);
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
434
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
435 // If the user has explicitly set an OldSize that is inconsistent
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
436 // with other command line flags, issue a warning.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
437 // The generation minimums and the overall heap mimimum should
a61af66fc99e Initial load
duke
parents:
diff changeset
438 // be within one heap alignment.
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
439 if ((_min_gen1_size + _min_gen0_size + min_alignment()) <
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
440 min_heap_byte_size()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
441 warning("Inconsistency between minimum heap size and minimum "
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
442 "generation sizes: using minimum heap = " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
443 min_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
444 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
445 if ((OldSize > _max_gen1_size)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
446 warning("Inconsistency between maximum heap size and maximum "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
447 "generation sizes: using maximum heap = " SIZE_FORMAT
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
448 " -XX:OldSize flag is being ignored",
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
449 max_heap_byte_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
450 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
451 // If there is an inconsistency between the OldSize and the minimum and/or
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
452 // initial size of gen0, since OldSize was explicitly set, OldSize wins.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
453 if (adjust_gen0_sizes(&_min_gen0_size, &_min_gen1_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
454 min_heap_byte_size(), OldSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
455 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
456 gclog_or_tty->print_cr("Minimum gen0 " SIZE_FORMAT " Initial gen0 "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
457 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
458 min_gen0_size(), initial_gen0_size(), max_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
459 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
460 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
461 // Initial size
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
462 if (adjust_gen0_sizes(&_initial_gen0_size, &_initial_gen1_size,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
463 initial_heap_byte_size(), OldSize)) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
464 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
465 gclog_or_tty->print_cr("Minimum gen0 " SIZE_FORMAT " Initial gen0 "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
466 SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
467 min_gen0_size(), initial_gen0_size(), max_gen0_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
468 }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
469 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
470 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
471 // Enforce the maximum gen1 size.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
472 set_min_gen1_size(MIN2(_min_gen1_size, _max_gen1_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
473
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
474 // Check that min gen1 <= initial gen1 <= max gen1
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
475 set_initial_gen1_size(MAX2(_initial_gen1_size, _min_gen1_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
476 set_initial_gen1_size(MIN2(_initial_gen1_size, _max_gen1_size));
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
477
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
478 if (PrintGCDetails && Verbose) {
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
479 gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT " Initial gen1 "
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
480 SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
481 min_gen1_size(), initial_gen1_size(), max_gen1_size());
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
482 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
483 }
a61af66fc99e Initial load
duke
parents:
diff changeset
484
a61af66fc99e Initial load
duke
parents:
diff changeset
485 HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
486 bool is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
487 bool* gc_overhead_limit_was_exceeded) {
a61af66fc99e Initial load
duke
parents:
diff changeset
488 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
489
a61af66fc99e Initial load
duke
parents:
diff changeset
490 debug_only(gch->check_for_valid_allocation_state());
a61af66fc99e Initial load
duke
parents:
diff changeset
491 assert(gch->no_gc_in_progress(), "Allocation during gc not allowed");
a61af66fc99e Initial load
duke
parents:
diff changeset
492 HeapWord* result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
493
a61af66fc99e Initial load
duke
parents:
diff changeset
494 // Loop until the allocation is satisified,
a61af66fc99e Initial load
duke
parents:
diff changeset
495 // or unsatisfied after GC.
a61af66fc99e Initial load
duke
parents:
diff changeset
496 for (int try_count = 1; /* return or throw */; try_count += 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
497 HandleMark hm; // discard any handles allocated in each iteration
a61af66fc99e Initial load
duke
parents:
diff changeset
498
a61af66fc99e Initial load
duke
parents:
diff changeset
499 // First allocation attempt is lock-free.
a61af66fc99e Initial load
duke
parents:
diff changeset
500 Generation *gen0 = gch->get_gen(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
501 assert(gen0->supports_inline_contig_alloc(),
a61af66fc99e Initial load
duke
parents:
diff changeset
502 "Otherwise, must do alloc within heap lock");
a61af66fc99e Initial load
duke
parents:
diff changeset
503 if (gen0->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
504 result = gen0->par_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
505 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
506 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
507 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
508 }
a61af66fc99e Initial load
duke
parents:
diff changeset
509 }
a61af66fc99e Initial load
duke
parents:
diff changeset
510 unsigned int gc_count_before; // read inside the Heap_lock locked region
a61af66fc99e Initial load
duke
parents:
diff changeset
511 {
a61af66fc99e Initial load
duke
parents:
diff changeset
512 MutexLocker ml(Heap_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
513 if (PrintGC && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
514 gclog_or_tty->print_cr("TwoGenerationCollectorPolicy::mem_allocate_work:"
a61af66fc99e Initial load
duke
parents:
diff changeset
515 " attempting locked slow path allocation");
a61af66fc99e Initial load
duke
parents:
diff changeset
516 }
a61af66fc99e Initial load
duke
parents:
diff changeset
517 // Note that only large objects get a shot at being
a61af66fc99e Initial load
duke
parents:
diff changeset
518 // allocated in later generations.
a61af66fc99e Initial load
duke
parents:
diff changeset
519 bool first_only = ! should_try_older_generation_allocation(size);
a61af66fc99e Initial load
duke
parents:
diff changeset
520
a61af66fc99e Initial load
duke
parents:
diff changeset
521 result = gch->attempt_allocation(size, is_tlab, first_only);
a61af66fc99e Initial load
duke
parents:
diff changeset
522 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
523 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
524 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
525 }
a61af66fc99e Initial load
duke
parents:
diff changeset
526
a61af66fc99e Initial load
duke
parents:
diff changeset
527 // There are NULL's returned for different circumstances below.
a61af66fc99e Initial load
duke
parents:
diff changeset
528 // In general gc_overhead_limit_was_exceeded should be false so
a61af66fc99e Initial load
duke
parents:
diff changeset
529 // set it so here and reset it to true only if the gc time
a61af66fc99e Initial load
duke
parents:
diff changeset
530 // limit is being exceeded as checked below.
a61af66fc99e Initial load
duke
parents:
diff changeset
531 *gc_overhead_limit_was_exceeded = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
532
a61af66fc99e Initial load
duke
parents:
diff changeset
533 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
534 if (is_tlab) {
a61af66fc99e Initial load
duke
parents:
diff changeset
535 return NULL; // Caller will retry allocating individual object
a61af66fc99e Initial load
duke
parents:
diff changeset
536 }
a61af66fc99e Initial load
duke
parents:
diff changeset
537 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
538 // Try and expand heap to satisfy request
a61af66fc99e Initial load
duke
parents:
diff changeset
539 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
540 // result could be null if we are out of space
a61af66fc99e Initial load
duke
parents:
diff changeset
541 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
542 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
543 }
a61af66fc99e Initial load
duke
parents:
diff changeset
544 }
a61af66fc99e Initial load
duke
parents:
diff changeset
545
a61af66fc99e Initial load
duke
parents:
diff changeset
546 // If this thread is not in a jni critical section, we stall
a61af66fc99e Initial load
duke
parents:
diff changeset
547 // the requestor until the critical section has cleared and
a61af66fc99e Initial load
duke
parents:
diff changeset
548 // GC allowed. When the critical section clears, a GC is
a61af66fc99e Initial load
duke
parents:
diff changeset
549 // initiated by the last thread exiting the critical section; so
a61af66fc99e Initial load
duke
parents:
diff changeset
550 // we retry the allocation sequence from the beginning of the loop,
a61af66fc99e Initial load
duke
parents:
diff changeset
551 // rather than causing more, now probably unnecessary, GC attempts.
a61af66fc99e Initial load
duke
parents:
diff changeset
552 JavaThread* jthr = JavaThread::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
553 if (!jthr->in_critical()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
554 MutexUnlocker mul(Heap_lock);
a61af66fc99e Initial load
duke
parents:
diff changeset
555 // Wait for JNI critical section to be exited
a61af66fc99e Initial load
duke
parents:
diff changeset
556 GC_locker::stall_until_clear();
a61af66fc99e Initial load
duke
parents:
diff changeset
557 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
558 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
559 if (CheckJNICalls) {
a61af66fc99e Initial load
duke
parents:
diff changeset
560 fatal("Possible deadlock due to allocating while"
a61af66fc99e Initial load
duke
parents:
diff changeset
561 " in jni critical section");
a61af66fc99e Initial load
duke
parents:
diff changeset
562 }
a61af66fc99e Initial load
duke
parents:
diff changeset
563 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
564 }
a61af66fc99e Initial load
duke
parents:
diff changeset
565 }
a61af66fc99e Initial load
duke
parents:
diff changeset
566
a61af66fc99e Initial load
duke
parents:
diff changeset
567 // Read the gc count while the heap lock is held.
a61af66fc99e Initial load
duke
parents:
diff changeset
568 gc_count_before = Universe::heap()->total_collections();
a61af66fc99e Initial load
duke
parents:
diff changeset
569 }
a61af66fc99e Initial load
duke
parents:
diff changeset
570
a61af66fc99e Initial load
duke
parents:
diff changeset
571 // Allocation has failed and a collection is about
a61af66fc99e Initial load
duke
parents:
diff changeset
572 // to be done. If the gc time limit was exceeded the
a61af66fc99e Initial load
duke
parents:
diff changeset
573 // last time a collection was done, return NULL so
a61af66fc99e Initial load
duke
parents:
diff changeset
574 // that an out-of-memory will be thrown. Clear
a61af66fc99e Initial load
duke
parents:
diff changeset
575 // gc_time_limit_exceeded so that subsequent attempts
a61af66fc99e Initial load
duke
parents:
diff changeset
576 // at a collection will be made.
a61af66fc99e Initial load
duke
parents:
diff changeset
577 if (size_policy()->gc_time_limit_exceeded()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
578 *gc_overhead_limit_was_exceeded = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
579 size_policy()->set_gc_time_limit_exceeded(false);
a61af66fc99e Initial load
duke
parents:
diff changeset
580 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
581 }
a61af66fc99e Initial load
duke
parents:
diff changeset
582
a61af66fc99e Initial load
duke
parents:
diff changeset
583 VM_GenCollectForAllocation op(size,
a61af66fc99e Initial load
duke
parents:
diff changeset
584 is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
585 gc_count_before);
a61af66fc99e Initial load
duke
parents:
diff changeset
586 VMThread::execute(&op);
a61af66fc99e Initial load
duke
parents:
diff changeset
587 if (op.prologue_succeeded()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
588 result = op.result();
a61af66fc99e Initial load
duke
parents:
diff changeset
589 if (op.gc_locked()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
590 assert(result == NULL, "must be NULL if gc_locked() is true");
a61af66fc99e Initial load
duke
parents:
diff changeset
591 continue; // retry and/or stall as necessary
a61af66fc99e Initial load
duke
parents:
diff changeset
592 }
a61af66fc99e Initial load
duke
parents:
diff changeset
593 assert(result == NULL || gch->is_in_reserved(result),
a61af66fc99e Initial load
duke
parents:
diff changeset
594 "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
595 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
596 }
a61af66fc99e Initial load
duke
parents:
diff changeset
597
a61af66fc99e Initial load
duke
parents:
diff changeset
598 // Give a warning if we seem to be looping forever.
a61af66fc99e Initial load
duke
parents:
diff changeset
599 if ((QueuedAllocationWarningCount > 0) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
600 (try_count % QueuedAllocationWarningCount == 0)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
601 warning("TwoGenerationCollectorPolicy::mem_allocate_work retries %d times \n\t"
a61af66fc99e Initial load
duke
parents:
diff changeset
602 " size=%d %s", try_count, size, is_tlab ? "(TLAB)" : "");
a61af66fc99e Initial load
duke
parents:
diff changeset
603 }
a61af66fc99e Initial load
duke
parents:
diff changeset
604 }
a61af66fc99e Initial load
duke
parents:
diff changeset
605 }
a61af66fc99e Initial load
duke
parents:
diff changeset
606
a61af66fc99e Initial load
duke
parents:
diff changeset
607 HeapWord* GenCollectorPolicy::expand_heap_and_allocate(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
608 bool is_tlab) {
a61af66fc99e Initial load
duke
parents:
diff changeset
609 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
610 HeapWord* result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
611 for (int i = number_of_generations() - 1; i >= 0 && result == NULL; i--) {
a61af66fc99e Initial load
duke
parents:
diff changeset
612 Generation *gen = gch->get_gen(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
613 if (gen->should_allocate(size, is_tlab)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
614 result = gen->expand_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
615 }
a61af66fc99e Initial load
duke
parents:
diff changeset
616 }
a61af66fc99e Initial load
duke
parents:
diff changeset
617 assert(result == NULL || gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
618 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
619 }
a61af66fc99e Initial load
duke
parents:
diff changeset
620
a61af66fc99e Initial load
duke
parents:
diff changeset
621 HeapWord* GenCollectorPolicy::satisfy_failed_allocation(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
622 bool is_tlab) {
a61af66fc99e Initial load
duke
parents:
diff changeset
623 GenCollectedHeap *gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
624 GCCauseSetter x(gch, GCCause::_allocation_failure);
a61af66fc99e Initial load
duke
parents:
diff changeset
625 HeapWord* result = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
626
a61af66fc99e Initial load
duke
parents:
diff changeset
627 assert(size != 0, "Precondition violated");
a61af66fc99e Initial load
duke
parents:
diff changeset
628 if (GC_locker::is_active_and_needs_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
629 // GC locker is active; instead of a collection we will attempt
a61af66fc99e Initial load
duke
parents:
diff changeset
630 // to expand the heap, if there's room for expansion.
a61af66fc99e Initial load
duke
parents:
diff changeset
631 if (!gch->is_maximal_no_gc()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
632 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
633 }
a61af66fc99e Initial load
duke
parents:
diff changeset
634 return result; // could be null if we are out of space
a61af66fc99e Initial load
duke
parents:
diff changeset
635 } else if (!gch->incremental_collection_will_fail()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
636 // The gc_prologues have not executed yet. The value
a61af66fc99e Initial load
duke
parents:
diff changeset
637 // for incremental_collection_will_fail() is the remanent
a61af66fc99e Initial load
duke
parents:
diff changeset
638 // of the last collection.
a61af66fc99e Initial load
duke
parents:
diff changeset
639 // Do an incremental collection.
a61af66fc99e Initial load
duke
parents:
diff changeset
640 gch->do_collection(false /* full */,
a61af66fc99e Initial load
duke
parents:
diff changeset
641 false /* clear_all_soft_refs */,
a61af66fc99e Initial load
duke
parents:
diff changeset
642 size /* size */,
a61af66fc99e Initial load
duke
parents:
diff changeset
643 is_tlab /* is_tlab */,
a61af66fc99e Initial load
duke
parents:
diff changeset
644 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load
duke
parents:
diff changeset
645 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
646 // Try a full collection; see delta for bug id 6266275
a61af66fc99e Initial load
duke
parents:
diff changeset
647 // for the original code and why this has been simplified
a61af66fc99e Initial load
duke
parents:
diff changeset
648 // with from-space allocation criteria modified and
a61af66fc99e Initial load
duke
parents:
diff changeset
649 // such allocation moved out of the safepoint path.
a61af66fc99e Initial load
duke
parents:
diff changeset
650 gch->do_collection(true /* full */,
a61af66fc99e Initial load
duke
parents:
diff changeset
651 false /* clear_all_soft_refs */,
a61af66fc99e Initial load
duke
parents:
diff changeset
652 size /* size */,
a61af66fc99e Initial load
duke
parents:
diff changeset
653 is_tlab /* is_tlab */,
a61af66fc99e Initial load
duke
parents:
diff changeset
654 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load
duke
parents:
diff changeset
655 }
a61af66fc99e Initial load
duke
parents:
diff changeset
656
a61af66fc99e Initial load
duke
parents:
diff changeset
657 result = gch->attempt_allocation(size, is_tlab, false /*first_only*/);
a61af66fc99e Initial load
duke
parents:
diff changeset
658
a61af66fc99e Initial load
duke
parents:
diff changeset
659 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
660 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
661 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
662 }
a61af66fc99e Initial load
duke
parents:
diff changeset
663
a61af66fc99e Initial load
duke
parents:
diff changeset
664 // OK, collection failed, try expansion.
a61af66fc99e Initial load
duke
parents:
diff changeset
665 result = expand_heap_and_allocate(size, is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
666 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
667 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
668 }
a61af66fc99e Initial load
duke
parents:
diff changeset
669
a61af66fc99e Initial load
duke
parents:
diff changeset
670 // If we reach this point, we're really out of memory. Try every trick
a61af66fc99e Initial load
duke
parents:
diff changeset
671 // we can to reclaim memory. Force collection of soft references. Force
a61af66fc99e Initial load
duke
parents:
diff changeset
672 // a complete compaction of the heap. Any additional methods for finding
a61af66fc99e Initial load
duke
parents:
diff changeset
673 // free memory should be here, especially if they are expensive. If this
a61af66fc99e Initial load
duke
parents:
diff changeset
674 // attempt fails, an OOM exception will be thrown.
a61af66fc99e Initial load
duke
parents:
diff changeset
675 {
a61af66fc99e Initial load
duke
parents:
diff changeset
676 IntFlagSetting flag_change(MarkSweepAlwaysCompactCount, 1); // Make sure the heap is fully compacted
a61af66fc99e Initial load
duke
parents:
diff changeset
677
a61af66fc99e Initial load
duke
parents:
diff changeset
678 gch->do_collection(true /* full */,
a61af66fc99e Initial load
duke
parents:
diff changeset
679 true /* clear_all_soft_refs */,
a61af66fc99e Initial load
duke
parents:
diff changeset
680 size /* size */,
a61af66fc99e Initial load
duke
parents:
diff changeset
681 is_tlab /* is_tlab */,
a61af66fc99e Initial load
duke
parents:
diff changeset
682 number_of_generations() - 1 /* max_level */);
a61af66fc99e Initial load
duke
parents:
diff changeset
683 }
a61af66fc99e Initial load
duke
parents:
diff changeset
684
a61af66fc99e Initial load
duke
parents:
diff changeset
685 result = gch->attempt_allocation(size, is_tlab, false /* first_only */);
a61af66fc99e Initial load
duke
parents:
diff changeset
686 if (result != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
687 assert(gch->is_in_reserved(result), "result not in heap");
a61af66fc99e Initial load
duke
parents:
diff changeset
688 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
689 }
a61af66fc99e Initial load
duke
parents:
diff changeset
690
a61af66fc99e Initial load
duke
parents:
diff changeset
691 // What else? We might try synchronous finalization later. If the total
a61af66fc99e Initial load
duke
parents:
diff changeset
692 // space available is large enough for the allocation, then a more
a61af66fc99e Initial load
duke
parents:
diff changeset
693 // complete compaction phase than we've tried so far might be
a61af66fc99e Initial load
duke
parents:
diff changeset
694 // appropriate.
a61af66fc99e Initial load
duke
parents:
diff changeset
695 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
696 }
a61af66fc99e Initial load
duke
parents:
diff changeset
697
a61af66fc99e Initial load
duke
parents:
diff changeset
698 size_t GenCollectorPolicy::large_typearray_limit() {
a61af66fc99e Initial load
duke
parents:
diff changeset
699 return FastAllocateSizeLimit;
a61af66fc99e Initial load
duke
parents:
diff changeset
700 }
a61af66fc99e Initial load
duke
parents:
diff changeset
701
a61af66fc99e Initial load
duke
parents:
diff changeset
702 // Return true if any of the following is true:
a61af66fc99e Initial load
duke
parents:
diff changeset
703 // . the allocation won't fit into the current young gen heap
a61af66fc99e Initial load
duke
parents:
diff changeset
704 // . gc locker is occupied (jni critical section)
a61af66fc99e Initial load
duke
parents:
diff changeset
705 // . heap memory is tight -- the most recent previous collection
a61af66fc99e Initial load
duke
parents:
diff changeset
706 // was a full collection because a partial collection (would
a61af66fc99e Initial load
duke
parents:
diff changeset
707 // have) failed and is likely to fail again
a61af66fc99e Initial load
duke
parents:
diff changeset
708 bool GenCollectorPolicy::should_try_older_generation_allocation(
a61af66fc99e Initial load
duke
parents:
diff changeset
709 size_t word_size) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
710 GenCollectedHeap* gch = GenCollectedHeap::heap();
a61af66fc99e Initial load
duke
parents:
diff changeset
711 size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
a61af66fc99e Initial load
duke
parents:
diff changeset
712 return (word_size > heap_word_size(gen0_capacity))
a61af66fc99e Initial load
duke
parents:
diff changeset
713 || (GC_locker::is_active_and_needs_gc())
a61af66fc99e Initial load
duke
parents:
diff changeset
714 || ( gch->last_incremental_collection_failed()
a61af66fc99e Initial load
duke
parents:
diff changeset
715 && gch->incremental_collection_will_fail());
a61af66fc99e Initial load
duke
parents:
diff changeset
716 }
a61af66fc99e Initial load
duke
parents:
diff changeset
717
a61af66fc99e Initial load
duke
parents:
diff changeset
718
a61af66fc99e Initial load
duke
parents:
diff changeset
719 //
a61af66fc99e Initial load
duke
parents:
diff changeset
720 // MarkSweepPolicy methods
a61af66fc99e Initial load
duke
parents:
diff changeset
721 //
a61af66fc99e Initial load
duke
parents:
diff changeset
722
a61af66fc99e Initial load
duke
parents:
diff changeset
723 MarkSweepPolicy::MarkSweepPolicy() {
a61af66fc99e Initial load
duke
parents:
diff changeset
724 initialize_all();
a61af66fc99e Initial load
duke
parents:
diff changeset
725 }
a61af66fc99e Initial load
duke
parents:
diff changeset
726
a61af66fc99e Initial load
duke
parents:
diff changeset
727 void MarkSweepPolicy::initialize_generations() {
a61af66fc99e Initial load
duke
parents:
diff changeset
728 initialize_perm_generation(PermGen::MarkSweepCompact);
a61af66fc99e Initial load
duke
parents:
diff changeset
729 _generations = new GenerationSpecPtr[number_of_generations()];
a61af66fc99e Initial load
duke
parents:
diff changeset
730 if (_generations == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
731 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load
duke
parents:
diff changeset
732
a61af66fc99e Initial load
duke
parents:
diff changeset
733 if (UseParNewGC && ParallelGCThreads > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
734 _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
735 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
736 _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
737 }
a61af66fc99e Initial load
duke
parents:
diff changeset
738 _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
739
a61af66fc99e Initial load
duke
parents:
diff changeset
740 if (_generations[0] == NULL || _generations[1] == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
741 vm_exit_during_initialization("Unable to allocate gen spec");
a61af66fc99e Initial load
duke
parents:
diff changeset
742 }
a61af66fc99e Initial load
duke
parents:
diff changeset
743
a61af66fc99e Initial load
duke
parents:
diff changeset
744 void MarkSweepPolicy::initialize_gc_policy_counters() {
a61af66fc99e Initial load
duke
parents:
diff changeset
745 // initialize the policy counters - 2 collectors, 3 generations
a61af66fc99e Initial load
duke
parents:
diff changeset
746 if (UseParNewGC && ParallelGCThreads > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
747 _gc_policy_counters = new GCPolicyCounters("ParNew:MSC", 2, 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
748 }
a61af66fc99e Initial load
duke
parents:
diff changeset
749 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
750 _gc_policy_counters = new GCPolicyCounters("Copy:MSC", 2, 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
751 }
a61af66fc99e Initial load
duke
parents:
diff changeset
752 }