annotate src/share/vm/memory/collectorPolicy.hpp @ 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 0bfd3fb24150
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 // This class (or more correctly, subtypes of this class)
a61af66fc99e Initial load
duke
parents:
diff changeset
26 // are used to define global garbage collector attributes.
a61af66fc99e Initial load
duke
parents:
diff changeset
27 // This includes initialization of generations and any other
a61af66fc99e Initial load
duke
parents:
diff changeset
28 // shared resources they may need.
a61af66fc99e Initial load
duke
parents:
diff changeset
29 //
a61af66fc99e Initial load
duke
parents:
diff changeset
30 // In general, all flag adjustment and validation should be
a61af66fc99e Initial load
duke
parents:
diff changeset
31 // done in initialize_flags(), which is called prior to
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // initialize_size_info().
a61af66fc99e Initial load
duke
parents:
diff changeset
33 //
a61af66fc99e Initial load
duke
parents:
diff changeset
34 // This class is not fully developed yet. As more collector(s)
a61af66fc99e Initial load
duke
parents:
diff changeset
35 // are added, it is expected that we will come across further
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // behavior that requires global attention. The correct place
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // to deal with those issues is this class.
a61af66fc99e Initial load
duke
parents:
diff changeset
38
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // Forward declarations.
a61af66fc99e Initial load
duke
parents:
diff changeset
40 class GenCollectorPolicy;
a61af66fc99e Initial load
duke
parents:
diff changeset
41 class TwoGenerationCollectorPolicy;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
42 class AdaptiveSizePolicy;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
43 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
44 class ConcurrentMarkSweepPolicy;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
45 class G1CollectorPolicy;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
46 #endif // SERIALGC
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
47
0
a61af66fc99e Initial load
duke
parents:
diff changeset
48 class GCPolicyCounters;
a61af66fc99e Initial load
duke
parents:
diff changeset
49 class PermanentGenerationSpec;
a61af66fc99e Initial load
duke
parents:
diff changeset
50 class MarkSweepPolicy;
a61af66fc99e Initial load
duke
parents:
diff changeset
51
a61af66fc99e Initial load
duke
parents:
diff changeset
52 class CollectorPolicy : public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
53 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
54 PermanentGenerationSpec *_permanent_generation;
a61af66fc99e Initial load
duke
parents:
diff changeset
55 GCPolicyCounters* _gc_policy_counters;
a61af66fc99e Initial load
duke
parents:
diff changeset
56
a61af66fc99e Initial load
duke
parents:
diff changeset
57 // Requires that the concrete subclass sets the alignment constraints
a61af66fc99e Initial load
duke
parents:
diff changeset
58 // before calling.
a61af66fc99e Initial load
duke
parents:
diff changeset
59 virtual void initialize_flags();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
60 virtual void initialize_size_info();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
61 // Initialize "_permanent_generation" to a spec for the given kind of
a61af66fc99e Initial load
duke
parents:
diff changeset
62 // Perm Gen.
a61af66fc99e Initial load
duke
parents:
diff changeset
63 void initialize_perm_generation(PermGen::Name pgnm);
a61af66fc99e Initial load
duke
parents:
diff changeset
64
a61af66fc99e Initial load
duke
parents:
diff changeset
65 size_t _initial_heap_byte_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
66 size_t _max_heap_byte_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
67 size_t _min_heap_byte_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
68
a61af66fc99e Initial load
duke
parents:
diff changeset
69 size_t _min_alignment;
a61af66fc99e Initial load
duke
parents:
diff changeset
70 size_t _max_alignment;
a61af66fc99e Initial load
duke
parents:
diff changeset
71
a61af66fc99e Initial load
duke
parents:
diff changeset
72 CollectorPolicy() :
a61af66fc99e Initial load
duke
parents:
diff changeset
73 _min_alignment(1),
a61af66fc99e Initial load
duke
parents:
diff changeset
74 _max_alignment(1),
a61af66fc99e Initial load
duke
parents:
diff changeset
75 _initial_heap_byte_size(0),
a61af66fc99e Initial load
duke
parents:
diff changeset
76 _max_heap_byte_size(0),
a61af66fc99e Initial load
duke
parents:
diff changeset
77 _min_heap_byte_size(0)
a61af66fc99e Initial load
duke
parents:
diff changeset
78 {}
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
81 void set_min_alignment(size_t align) { _min_alignment = align; }
a61af66fc99e Initial load
duke
parents:
diff changeset
82 size_t min_alignment() { return _min_alignment; }
a61af66fc99e Initial load
duke
parents:
diff changeset
83 void set_max_alignment(size_t align) { _max_alignment = align; }
a61af66fc99e Initial load
duke
parents:
diff changeset
84 size_t max_alignment() { return _max_alignment; }
a61af66fc99e Initial load
duke
parents:
diff changeset
85
a61af66fc99e Initial load
duke
parents:
diff changeset
86 size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
87 void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
88 size_t max_heap_byte_size() { return _max_heap_byte_size; }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
89 void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
90 size_t min_heap_byte_size() { return _min_heap_byte_size; }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
91 void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
92
a61af66fc99e Initial load
duke
parents:
diff changeset
93 enum Name {
a61af66fc99e Initial load
duke
parents:
diff changeset
94 CollectorPolicyKind,
a61af66fc99e Initial load
duke
parents:
diff changeset
95 TwoGenerationCollectorPolicyKind,
a61af66fc99e Initial load
duke
parents:
diff changeset
96 ConcurrentMarkSweepPolicyKind,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
97 ASConcurrentMarkSweepPolicyKind,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
98 G1CollectorPolicyKind
0
a61af66fc99e Initial load
duke
parents:
diff changeset
99 };
a61af66fc99e Initial load
duke
parents:
diff changeset
100
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // Identification methods.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
102 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
103 virtual TwoGenerationCollectorPolicy* as_two_generation_policy() { return NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
104 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
105 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
106 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
107 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
108 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // Note that these are not virtual.
a61af66fc99e Initial load
duke
parents:
diff changeset
110 bool is_generation_policy() { return as_generation_policy() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
111 bool is_two_generation_policy() { return as_two_generation_policy() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
112 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
113 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
114 bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
115 bool is_g1_policy() { return as_g1_policy() != NULL; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
116 #else // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
117 bool is_concurrent_mark_sweep_policy() { return false; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
118 bool is_g1_policy() { return false; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
119 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
120
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
121
0
a61af66fc99e Initial load
duke
parents:
diff changeset
122 virtual PermanentGenerationSpec *permanent_generation() {
a61af66fc99e Initial load
duke
parents:
diff changeset
123 assert(_permanent_generation != NULL, "Sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
124 return _permanent_generation;
a61af66fc99e Initial load
duke
parents:
diff changeset
125 }
a61af66fc99e Initial load
duke
parents:
diff changeset
126
a61af66fc99e Initial load
duke
parents:
diff changeset
127 virtual BarrierSet::Name barrier_set_name() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
128 virtual GenRemSet::Name rem_set_name() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
129
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // Create the remembered set (to cover the given reserved region,
a61af66fc99e Initial load
duke
parents:
diff changeset
131 // allowing breaking up into at most "max_covered_regions").
a61af66fc99e Initial load
duke
parents:
diff changeset
132 virtual GenRemSet* create_rem_set(MemRegion reserved,
a61af66fc99e Initial load
duke
parents:
diff changeset
133 int max_covered_regions);
a61af66fc99e Initial load
duke
parents:
diff changeset
134
a61af66fc99e Initial load
duke
parents:
diff changeset
135 // This method controls how a collector satisfies a request
a61af66fc99e Initial load
duke
parents:
diff changeset
136 // for a block of memory. "gc_time_limit_was_exceeded" will
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // be set to true if the adaptive size policy determine that
a61af66fc99e Initial load
duke
parents:
diff changeset
138 // an excessive amount of time is being spent doing collections
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // and caused a NULL to be returned. If a NULL is not returned,
a61af66fc99e Initial load
duke
parents:
diff changeset
140 // "gc_time_limit_was_exceeded" has an undefined meaning.
a61af66fc99e Initial load
duke
parents:
diff changeset
141 virtual HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
142 bool is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
143 bool* gc_overhead_limit_was_exceeded) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
144
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // This method controls how a collector handles one or more
a61af66fc99e Initial load
duke
parents:
diff changeset
146 // of its generations being fully allocated.
a61af66fc99e Initial load
duke
parents:
diff changeset
147 virtual HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // Performace Counter support
a61af66fc99e Initial load
duke
parents:
diff changeset
149 GCPolicyCounters* counters() { return _gc_policy_counters; }
a61af66fc99e Initial load
duke
parents:
diff changeset
150
a61af66fc99e Initial load
duke
parents:
diff changeset
151 // Create the jstat counters for the GC policy. By default, policy's
a61af66fc99e Initial load
duke
parents:
diff changeset
152 // don't have associated counters, and we complain if this is invoked.
a61af66fc99e Initial load
duke
parents:
diff changeset
153 virtual void initialize_gc_policy_counters() {
a61af66fc99e Initial load
duke
parents:
diff changeset
154 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
155 }
a61af66fc99e Initial load
duke
parents:
diff changeset
156
a61af66fc99e Initial load
duke
parents:
diff changeset
157 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load
duke
parents:
diff changeset
158 return CollectorPolicy::CollectorPolicyKind;
a61af66fc99e Initial load
duke
parents:
diff changeset
159 }
a61af66fc99e Initial load
duke
parents:
diff changeset
160
a61af66fc99e Initial load
duke
parents:
diff changeset
161 // Returns true if a collector has eden space with soft end.
a61af66fc99e Initial load
duke
parents:
diff changeset
162 virtual bool has_soft_ended_eden() {
a61af66fc99e Initial load
duke
parents:
diff changeset
163 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
164 }
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 };
a61af66fc99e Initial load
duke
parents:
diff changeset
167
a61af66fc99e Initial load
duke
parents:
diff changeset
168 class GenCollectorPolicy : public CollectorPolicy {
a61af66fc99e Initial load
duke
parents:
diff changeset
169 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
170 size_t _min_gen0_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
171 size_t _initial_gen0_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
172 size_t _max_gen0_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
173
a61af66fc99e Initial load
duke
parents:
diff changeset
174 GenerationSpec **_generations;
a61af66fc99e Initial load
duke
parents:
diff changeset
175
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // The sizing of the different generations in the heap are controlled
a61af66fc99e Initial load
duke
parents:
diff changeset
177 // by a sizing policy.
a61af66fc99e Initial load
duke
parents:
diff changeset
178 AdaptiveSizePolicy* _size_policy;
a61af66fc99e Initial load
duke
parents:
diff changeset
179
a61af66fc99e Initial load
duke
parents:
diff changeset
180 // Return true if an allocation should be attempted in the older
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // generation if it fails in the younger generation. Return
a61af66fc99e Initial load
duke
parents:
diff changeset
182 // false, otherwise.
a61af66fc99e Initial load
duke
parents:
diff changeset
183 virtual bool should_try_older_generation_allocation(size_t word_size) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
184
a61af66fc99e Initial load
duke
parents:
diff changeset
185 void initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
186 void initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
187
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // Try to allocate space by expanding the heap.
a61af66fc99e Initial load
duke
parents:
diff changeset
189 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
190
a61af66fc99e Initial load
duke
parents:
diff changeset
191 // compute max heap alignment
a61af66fc99e Initial load
duke
parents:
diff changeset
192 size_t compute_max_alignment();
a61af66fc99e Initial load
duke
parents:
diff changeset
193
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
194 // Scale the base_size by NewRation according to
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
195 // result = base_size / (NewRatio + 1)
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
196 // and align by min_alignment()
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
197 size_t 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
198
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
199 // Bound the value by the given maximum minus the
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
200 // min_alignment.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
201 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 public:
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
204 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
205 size_t min_gen0_size() { return _min_gen0_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
206 void set_min_gen0_size(size_t v) { _min_gen0_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
207 size_t initial_gen0_size() { return _initial_gen0_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
208 void set_initial_gen0_size(size_t v) { _initial_gen0_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
209 size_t max_gen0_size() { return _max_gen0_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
210 void set_max_gen0_size(size_t v) { _max_gen0_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
211
0
a61af66fc99e Initial load
duke
parents:
diff changeset
212 virtual int number_of_generations() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
213
a61af66fc99e Initial load
duke
parents:
diff changeset
214 virtual GenerationSpec **generations() {
a61af66fc99e Initial load
duke
parents:
diff changeset
215 assert(_generations != NULL, "Sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
216 return _generations;
a61af66fc99e Initial load
duke
parents:
diff changeset
217 }
a61af66fc99e Initial load
duke
parents:
diff changeset
218
a61af66fc99e Initial load
duke
parents:
diff changeset
219 virtual GenCollectorPolicy* as_generation_policy() { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
220
a61af66fc99e Initial load
duke
parents:
diff changeset
221 virtual void initialize_generations() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
222
a61af66fc99e Initial load
duke
parents:
diff changeset
223 virtual void initialize_all() {
a61af66fc99e Initial load
duke
parents:
diff changeset
224 initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
225 initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
226 initialize_generations();
a61af66fc99e Initial load
duke
parents:
diff changeset
227 }
a61af66fc99e Initial load
duke
parents:
diff changeset
228
a61af66fc99e Initial load
duke
parents:
diff changeset
229 HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
230 bool is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
231 bool* gc_overhead_limit_was_exceeded);
a61af66fc99e Initial load
duke
parents:
diff changeset
232
a61af66fc99e Initial load
duke
parents:
diff changeset
233 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
234
a61af66fc99e Initial load
duke
parents:
diff changeset
235 // The size that defines a "large array".
a61af66fc99e Initial load
duke
parents:
diff changeset
236 virtual size_t large_typearray_limit();
a61af66fc99e Initial load
duke
parents:
diff changeset
237
a61af66fc99e Initial load
duke
parents:
diff changeset
238 // Adaptive size policy
a61af66fc99e Initial load
duke
parents:
diff changeset
239 AdaptiveSizePolicy* size_policy() { return _size_policy; }
a61af66fc99e Initial load
duke
parents:
diff changeset
240 virtual void initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
241 size_t init_promo_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
242 size_t init_survivor_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
243
a61af66fc99e Initial load
duke
parents:
diff changeset
244 };
a61af66fc99e Initial load
duke
parents:
diff changeset
245
a61af66fc99e Initial load
duke
parents:
diff changeset
246
a61af66fc99e Initial load
duke
parents:
diff changeset
247 // All of hotspot's current collectors are subtypes of this
a61af66fc99e Initial load
duke
parents:
diff changeset
248 // class. Currently, these collectors all use the same gen[0],
a61af66fc99e Initial load
duke
parents:
diff changeset
249 // but have different gen[1] types. If we add another subtype
a61af66fc99e Initial load
duke
parents:
diff changeset
250 // of CollectorPolicy, this class should be broken out into
a61af66fc99e Initial load
duke
parents:
diff changeset
251 // its own file.
a61af66fc99e Initial load
duke
parents:
diff changeset
252
a61af66fc99e Initial load
duke
parents:
diff changeset
253 class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
a61af66fc99e Initial load
duke
parents:
diff changeset
254 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
255 size_t _min_gen1_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
256 size_t _initial_gen1_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
257 size_t _max_gen1_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
258
a61af66fc99e Initial load
duke
parents:
diff changeset
259 void initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
260 void initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
261 void initialize_generations() { ShouldNotReachHere(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
262
a61af66fc99e Initial load
duke
parents:
diff changeset
263 public:
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
264 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
265 size_t min_gen1_size() { return _min_gen1_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
266 void set_min_gen1_size(size_t v) { _min_gen1_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
267 size_t initial_gen1_size() { return _initial_gen1_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
268 void set_initial_gen1_size(size_t v) { _initial_gen1_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
269 size_t max_gen1_size() { return _max_gen1_size; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
270 void set_max_gen1_size(size_t v) { _max_gen1_size = v; }
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
271
0
a61af66fc99e Initial load
duke
parents:
diff changeset
272 // Inherited methods
a61af66fc99e Initial load
duke
parents:
diff changeset
273 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
274
a61af66fc99e Initial load
duke
parents:
diff changeset
275 int number_of_generations() { return 2; }
a61af66fc99e Initial load
duke
parents:
diff changeset
276 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
a61af66fc99e Initial load
duke
parents:
diff changeset
277 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; }
a61af66fc99e Initial load
duke
parents:
diff changeset
278
a61af66fc99e Initial load
duke
parents:
diff changeset
279 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load
duke
parents:
diff changeset
280 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
a61af66fc99e Initial load
duke
parents:
diff changeset
281 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
282
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
283 // Returns true is gen0 sizes were adjusted
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
284 bool adjust_gen0_sizes(size_t* gen0_size_ptr, size_t* gen1_size_ptr,
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
285 size_t heap_size, size_t min_gen1_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
286 };
a61af66fc99e Initial load
duke
parents:
diff changeset
287
a61af66fc99e Initial load
duke
parents:
diff changeset
288 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
a61af66fc99e Initial load
duke
parents:
diff changeset
289 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
290 void initialize_generations();
a61af66fc99e Initial load
duke
parents:
diff changeset
291
a61af66fc99e Initial load
duke
parents:
diff changeset
292 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
293 MarkSweepPolicy();
a61af66fc99e Initial load
duke
parents:
diff changeset
294
a61af66fc99e Initial load
duke
parents:
diff changeset
295 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
296
a61af66fc99e Initial load
duke
parents:
diff changeset
297 void initialize_gc_policy_counters();
a61af66fc99e Initial load
duke
parents:
diff changeset
298 };