annotate src/share/vm/memory/collectorPolicy.hpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children c9ca3f51cf41
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1387
diff changeset
2 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. 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 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1387
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1387
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1387
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
25 #ifndef SHARE_VM_MEMORY_COLLECTORPOLICY_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #define SHARE_VM_MEMORY_COLLECTORPOLICY_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "memory/barrierSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
29 #include "memory/genRemSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
30 #include "memory/permGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
31
0
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // This class (or more correctly, subtypes of this class)
a61af66fc99e Initial load
duke
parents:
diff changeset
33 // are used to define global garbage collector attributes.
a61af66fc99e Initial load
duke
parents:
diff changeset
34 // This includes initialization of generations and any other
a61af66fc99e Initial load
duke
parents:
diff changeset
35 // shared resources they may need.
a61af66fc99e Initial load
duke
parents:
diff changeset
36 //
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // In general, all flag adjustment and validation should be
a61af66fc99e Initial load
duke
parents:
diff changeset
38 // done in initialize_flags(), which is called prior to
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // initialize_size_info().
a61af66fc99e Initial load
duke
parents:
diff changeset
40 //
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // This class is not fully developed yet. As more collector(s)
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // are added, it is expected that we will come across further
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // behavior that requires global attention. The correct place
a61af66fc99e Initial load
duke
parents:
diff changeset
44 // to deal with those issues is this class.
a61af66fc99e Initial load
duke
parents:
diff changeset
45
a61af66fc99e Initial load
duke
parents:
diff changeset
46 // Forward declarations.
a61af66fc99e Initial load
duke
parents:
diff changeset
47 class GenCollectorPolicy;
a61af66fc99e Initial load
duke
parents:
diff changeset
48 class TwoGenerationCollectorPolicy;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
49 class AdaptiveSizePolicy;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
50 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
51 class ConcurrentMarkSweepPolicy;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
52 class G1CollectorPolicy;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
53 #endif // SERIALGC
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
54
0
a61af66fc99e Initial load
duke
parents:
diff changeset
55 class GCPolicyCounters;
a61af66fc99e Initial load
duke
parents:
diff changeset
56 class PermanentGenerationSpec;
a61af66fc99e Initial load
duke
parents:
diff changeset
57 class MarkSweepPolicy;
a61af66fc99e Initial load
duke
parents:
diff changeset
58
a61af66fc99e Initial load
duke
parents:
diff changeset
59 class CollectorPolicy : public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
60 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
61 PermanentGenerationSpec *_permanent_generation;
a61af66fc99e Initial load
duke
parents:
diff changeset
62 GCPolicyCounters* _gc_policy_counters;
a61af66fc99e Initial load
duke
parents:
diff changeset
63
a61af66fc99e Initial load
duke
parents:
diff changeset
64 // Requires that the concrete subclass sets the alignment constraints
a61af66fc99e Initial load
duke
parents:
diff changeset
65 // before calling.
a61af66fc99e Initial load
duke
parents:
diff changeset
66 virtual void initialize_flags();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
67 virtual void initialize_size_info();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
68 // Initialize "_permanent_generation" to a spec for the given kind of
a61af66fc99e Initial load
duke
parents:
diff changeset
69 // Perm Gen.
a61af66fc99e Initial load
duke
parents:
diff changeset
70 void initialize_perm_generation(PermGen::Name pgnm);
a61af66fc99e Initial load
duke
parents:
diff changeset
71
a61af66fc99e Initial load
duke
parents:
diff changeset
72 size_t _initial_heap_byte_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
73 size_t _max_heap_byte_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
74 size_t _min_heap_byte_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
75
a61af66fc99e Initial load
duke
parents:
diff changeset
76 size_t _min_alignment;
a61af66fc99e Initial load
duke
parents:
diff changeset
77 size_t _max_alignment;
a61af66fc99e Initial load
duke
parents:
diff changeset
78
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
79 // The sizing of the heap are controlled by a sizing policy.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
80 AdaptiveSizePolicy* _size_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
81
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
82 // Set to true when policy wants soft refs cleared.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
83 // Reset to false by gc after it clears all soft refs.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
84 bool _should_clear_all_soft_refs;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
85 // Set to true by the GC if the just-completed gc cleared all
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
86 // softrefs. This is set to true whenever a gc clears all softrefs, and
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
87 // set to false each time gc returns to the mutator. For example, in the
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
88 // ParallelScavengeHeap case the latter would be done toward the end of
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
89 // mem_allocate() where it returns op.result()
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
90 bool _all_soft_refs_clear;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
91
0
a61af66fc99e Initial load
duke
parents:
diff changeset
92 CollectorPolicy() :
a61af66fc99e Initial load
duke
parents:
diff changeset
93 _min_alignment(1),
a61af66fc99e Initial load
duke
parents:
diff changeset
94 _max_alignment(1),
a61af66fc99e Initial load
duke
parents:
diff changeset
95 _initial_heap_byte_size(0),
a61af66fc99e Initial load
duke
parents:
diff changeset
96 _max_heap_byte_size(0),
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
97 _min_heap_byte_size(0),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
98 _size_policy(NULL),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
99 _should_clear_all_soft_refs(false),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
100 _all_soft_refs_clear(false)
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 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
104 void set_min_alignment(size_t align) { _min_alignment = align; }
a61af66fc99e Initial load
duke
parents:
diff changeset
105 size_t min_alignment() { return _min_alignment; }
a61af66fc99e Initial load
duke
parents:
diff changeset
106 void set_max_alignment(size_t align) { _max_alignment = align; }
a61af66fc99e Initial load
duke
parents:
diff changeset
107 size_t max_alignment() { return _max_alignment; }
a61af66fc99e Initial load
duke
parents:
diff changeset
108
a61af66fc99e Initial load
duke
parents:
diff changeset
109 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
110 void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
111 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
112 void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
113 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
114 void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
115
a61af66fc99e Initial load
duke
parents:
diff changeset
116 enum Name {
a61af66fc99e Initial load
duke
parents:
diff changeset
117 CollectorPolicyKind,
a61af66fc99e Initial load
duke
parents:
diff changeset
118 TwoGenerationCollectorPolicyKind,
a61af66fc99e Initial load
duke
parents:
diff changeset
119 ConcurrentMarkSweepPolicyKind,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
120 ASConcurrentMarkSweepPolicyKind,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
121 G1CollectorPolicyKind
0
a61af66fc99e Initial load
duke
parents:
diff changeset
122 };
a61af66fc99e Initial load
duke
parents:
diff changeset
123
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
124 AdaptiveSizePolicy* size_policy() { return _size_policy; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
125 bool should_clear_all_soft_refs() { return _should_clear_all_soft_refs; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
126 void set_should_clear_all_soft_refs(bool v) { _should_clear_all_soft_refs = v; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
127 // Returns the current value of _should_clear_all_soft_refs.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
128 // _should_clear_all_soft_refs is set to false as a side effect.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
129 bool use_should_clear_all_soft_refs(bool v);
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
130 bool all_soft_refs_clear() { return _all_soft_refs_clear; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
131 void set_all_soft_refs_clear(bool v) { _all_soft_refs_clear = v; }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
132
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
133 // Called by the GC after Soft Refs have been cleared to indicate
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
134 // that the request in _should_clear_all_soft_refs has been fulfilled.
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
135 void cleared_all_soft_refs();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
136
0
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // Identification methods.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
138 virtual GenCollectorPolicy* as_generation_policy() { return NULL; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
139 virtual TwoGenerationCollectorPolicy* as_two_generation_policy() { return NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
140 virtual MarkSweepPolicy* as_mark_sweep_policy() { return NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
141 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
142 virtual ConcurrentMarkSweepPolicy* as_concurrent_mark_sweep_policy() { return NULL; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
143 virtual G1CollectorPolicy* as_g1_policy() { return NULL; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
144 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // Note that these are not virtual.
a61af66fc99e Initial load
duke
parents:
diff changeset
146 bool is_generation_policy() { return as_generation_policy() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
147 bool is_two_generation_policy() { return as_two_generation_policy() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
148 bool is_mark_sweep_policy() { return as_mark_sweep_policy() != NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
149 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
150 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
151 bool is_g1_policy() { return as_g1_policy() != NULL; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
152 #else // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
153 bool is_concurrent_mark_sweep_policy() { return false; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
154 bool is_g1_policy() { return false; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
155 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
156
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 13
diff changeset
157
0
a61af66fc99e Initial load
duke
parents:
diff changeset
158 virtual PermanentGenerationSpec *permanent_generation() {
a61af66fc99e Initial load
duke
parents:
diff changeset
159 assert(_permanent_generation != NULL, "Sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
160 return _permanent_generation;
a61af66fc99e Initial load
duke
parents:
diff changeset
161 }
a61af66fc99e Initial load
duke
parents:
diff changeset
162
a61af66fc99e Initial load
duke
parents:
diff changeset
163 virtual BarrierSet::Name barrier_set_name() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
164 virtual GenRemSet::Name rem_set_name() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
165
a61af66fc99e Initial load
duke
parents:
diff changeset
166 // Create the remembered set (to cover the given reserved region,
a61af66fc99e Initial load
duke
parents:
diff changeset
167 // allowing breaking up into at most "max_covered_regions").
a61af66fc99e Initial load
duke
parents:
diff changeset
168 virtual GenRemSet* create_rem_set(MemRegion reserved,
a61af66fc99e Initial load
duke
parents:
diff changeset
169 int max_covered_regions);
a61af66fc99e Initial load
duke
parents:
diff changeset
170
a61af66fc99e Initial load
duke
parents:
diff changeset
171 // This method controls how a collector satisfies a request
a61af66fc99e Initial load
duke
parents:
diff changeset
172 // for a block of memory. "gc_time_limit_was_exceeded" will
a61af66fc99e Initial load
duke
parents:
diff changeset
173 // be set to true if the adaptive size policy determine that
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // an excessive amount of time is being spent doing collections
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // and caused a NULL to be returned. If a NULL is not returned,
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // "gc_time_limit_was_exceeded" has an undefined meaning.
a61af66fc99e Initial load
duke
parents:
diff changeset
177 virtual HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
178 bool is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
179 bool* gc_overhead_limit_was_exceeded) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
180
a61af66fc99e Initial load
duke
parents:
diff changeset
181 // This method controls how a collector handles one or more
a61af66fc99e Initial load
duke
parents:
diff changeset
182 // of its generations being fully allocated.
a61af66fc99e Initial load
duke
parents:
diff changeset
183 virtual HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
184 // Performace Counter support
a61af66fc99e Initial load
duke
parents:
diff changeset
185 GCPolicyCounters* counters() { return _gc_policy_counters; }
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 // Create the jstat counters for the GC policy. By default, policy's
a61af66fc99e Initial load
duke
parents:
diff changeset
188 // don't have associated counters, and we complain if this is invoked.
a61af66fc99e Initial load
duke
parents:
diff changeset
189 virtual void initialize_gc_policy_counters() {
a61af66fc99e Initial load
duke
parents:
diff changeset
190 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
191 }
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load
duke
parents:
diff changeset
194 return CollectorPolicy::CollectorPolicyKind;
a61af66fc99e Initial load
duke
parents:
diff changeset
195 }
a61af66fc99e Initial load
duke
parents:
diff changeset
196
a61af66fc99e Initial load
duke
parents:
diff changeset
197 // Returns true if a collector has eden space with soft end.
a61af66fc99e Initial load
duke
parents:
diff changeset
198 virtual bool has_soft_ended_eden() {
a61af66fc99e Initial load
duke
parents:
diff changeset
199 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
200 }
a61af66fc99e Initial load
duke
parents:
diff changeset
201
a61af66fc99e Initial load
duke
parents:
diff changeset
202 };
a61af66fc99e Initial load
duke
parents:
diff changeset
203
1387
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
204 class ClearedAllSoftRefs : public StackObj {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
205 bool _clear_all_soft_refs;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
206 CollectorPolicy* _collector_policy;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
207 public:
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
208 ClearedAllSoftRefs(bool clear_all_soft_refs,
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
209 CollectorPolicy* collector_policy) :
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
210 _clear_all_soft_refs(clear_all_soft_refs),
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
211 _collector_policy(collector_policy) {}
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
212
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
213 ~ClearedAllSoftRefs() {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
214 if (_clear_all_soft_refs) {
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
215 _collector_policy->cleared_all_soft_refs();
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
216 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
217 }
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
218 };
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 356
diff changeset
219
0
a61af66fc99e Initial load
duke
parents:
diff changeset
220 class GenCollectorPolicy : public CollectorPolicy {
a61af66fc99e Initial load
duke
parents:
diff changeset
221 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
222 size_t _min_gen0_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
223 size_t _initial_gen0_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
224 size_t _max_gen0_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 GenerationSpec **_generations;
a61af66fc99e Initial load
duke
parents:
diff changeset
227
a61af66fc99e Initial load
duke
parents:
diff changeset
228 // Return true if an allocation should be attempted in the older
a61af66fc99e Initial load
duke
parents:
diff changeset
229 // generation if it fails in the younger generation. Return
a61af66fc99e Initial load
duke
parents:
diff changeset
230 // false, otherwise.
a61af66fc99e Initial load
duke
parents:
diff changeset
231 virtual bool should_try_older_generation_allocation(size_t word_size) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
232
a61af66fc99e Initial load
duke
parents:
diff changeset
233 void initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
234 void initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 // Try to allocate space by expanding the heap.
a61af66fc99e Initial load
duke
parents:
diff changeset
237 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
238
a61af66fc99e Initial load
duke
parents:
diff changeset
239 // compute max heap alignment
a61af66fc99e Initial load
duke
parents:
diff changeset
240 size_t compute_max_alignment();
a61af66fc99e Initial load
duke
parents:
diff changeset
241
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
242 // 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
243 // result = base_size / (NewRatio + 1)
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
244 // and align by min_alignment()
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
245 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
246
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
247 // 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
248 // min_alignment.
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
249 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
250
a61af66fc99e Initial load
duke
parents:
diff changeset
251 public:
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
252 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
253 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
254 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
255 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
256 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
257 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
258 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
259
0
a61af66fc99e Initial load
duke
parents:
diff changeset
260 virtual int number_of_generations() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
261
a61af66fc99e Initial load
duke
parents:
diff changeset
262 virtual GenerationSpec **generations() {
a61af66fc99e Initial load
duke
parents:
diff changeset
263 assert(_generations != NULL, "Sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
264 return _generations;
a61af66fc99e Initial load
duke
parents:
diff changeset
265 }
a61af66fc99e Initial load
duke
parents:
diff changeset
266
a61af66fc99e Initial load
duke
parents:
diff changeset
267 virtual GenCollectorPolicy* as_generation_policy() { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
269 virtual void initialize_generations() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
270
a61af66fc99e Initial load
duke
parents:
diff changeset
271 virtual void initialize_all() {
a61af66fc99e Initial load
duke
parents:
diff changeset
272 initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
273 initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
274 initialize_generations();
a61af66fc99e Initial load
duke
parents:
diff changeset
275 }
a61af66fc99e Initial load
duke
parents:
diff changeset
276
a61af66fc99e Initial load
duke
parents:
diff changeset
277 HeapWord* mem_allocate_work(size_t size,
a61af66fc99e Initial load
duke
parents:
diff changeset
278 bool is_tlab,
a61af66fc99e Initial load
duke
parents:
diff changeset
279 bool* gc_overhead_limit_was_exceeded);
a61af66fc99e Initial load
duke
parents:
diff changeset
280
a61af66fc99e Initial load
duke
parents:
diff changeset
281 HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
282
a61af66fc99e Initial load
duke
parents:
diff changeset
283 // The size that defines a "large array".
a61af66fc99e Initial load
duke
parents:
diff changeset
284 virtual size_t large_typearray_limit();
a61af66fc99e Initial load
duke
parents:
diff changeset
285
a61af66fc99e Initial load
duke
parents:
diff changeset
286 // Adaptive size policy
a61af66fc99e Initial load
duke
parents:
diff changeset
287 virtual void initialize_size_policy(size_t init_eden_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
288 size_t init_promo_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
289 size_t init_survivor_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
290 };
a61af66fc99e Initial load
duke
parents:
diff changeset
291
a61af66fc99e Initial load
duke
parents:
diff changeset
292 // All of hotspot's current collectors are subtypes of this
a61af66fc99e Initial load
duke
parents:
diff changeset
293 // class. Currently, these collectors all use the same gen[0],
a61af66fc99e Initial load
duke
parents:
diff changeset
294 // but have different gen[1] types. If we add another subtype
a61af66fc99e Initial load
duke
parents:
diff changeset
295 // of CollectorPolicy, this class should be broken out into
a61af66fc99e Initial load
duke
parents:
diff changeset
296 // its own file.
a61af66fc99e Initial load
duke
parents:
diff changeset
297
a61af66fc99e Initial load
duke
parents:
diff changeset
298 class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
a61af66fc99e Initial load
duke
parents:
diff changeset
299 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
300 size_t _min_gen1_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
301 size_t _initial_gen1_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
302 size_t _max_gen1_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
303
a61af66fc99e Initial load
duke
parents:
diff changeset
304 void initialize_flags();
a61af66fc99e Initial load
duke
parents:
diff changeset
305 void initialize_size_info();
a61af66fc99e Initial load
duke
parents:
diff changeset
306 void initialize_generations() { ShouldNotReachHere(); }
a61af66fc99e Initial load
duke
parents:
diff changeset
307
a61af66fc99e Initial load
duke
parents:
diff changeset
308 public:
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
309 // Accessors
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
310 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
311 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
312 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
313 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
314 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
315 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
316
0
a61af66fc99e Initial load
duke
parents:
diff changeset
317 // Inherited methods
a61af66fc99e Initial load
duke
parents:
diff changeset
318 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
319
a61af66fc99e Initial load
duke
parents:
diff changeset
320 int number_of_generations() { return 2; }
a61af66fc99e Initial load
duke
parents:
diff changeset
321 BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }
a61af66fc99e Initial load
duke
parents:
diff changeset
322 GenRemSet::Name rem_set_name() { return GenRemSet::CardTable; }
a61af66fc99e Initial load
duke
parents:
diff changeset
323
a61af66fc99e Initial load
duke
parents:
diff changeset
324 virtual CollectorPolicy::Name kind() {
a61af66fc99e Initial load
duke
parents:
diff changeset
325 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
a61af66fc99e Initial load
duke
parents:
diff changeset
326 }
13
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
327
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
328 // Returns true is gen0 sizes were adjusted
183f41cf8bfe 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 0
diff changeset
329 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
330 size_t heap_size, size_t min_gen1_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
331 };
a61af66fc99e Initial load
duke
parents:
diff changeset
332
a61af66fc99e Initial load
duke
parents:
diff changeset
333 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
a61af66fc99e Initial load
duke
parents:
diff changeset
334 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
335 void initialize_generations();
a61af66fc99e Initial load
duke
parents:
diff changeset
336
a61af66fc99e Initial load
duke
parents:
diff changeset
337 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
338 MarkSweepPolicy();
a61af66fc99e Initial load
duke
parents:
diff changeset
339
a61af66fc99e Initial load
duke
parents:
diff changeset
340 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
a61af66fc99e Initial load
duke
parents:
diff changeset
341
a61af66fc99e Initial load
duke
parents:
diff changeset
342 void initialize_gc_policy_counters();
a61af66fc99e Initial load
duke
parents:
diff changeset
343 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
344
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
345 #endif // SHARE_VM_MEMORY_COLLECTORPOLICY_HPP