Thu, 20 Nov 2008 16:56:09 -0800
6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa
1 /*
2 * Copyright 2004-2005 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 // CMSGCAdaptivePolicyCounters is a holder class for performance counters
26 // that track the data and decisions for the ergonomics policy for the
27 // concurrent mark sweep collector
29 class CMSGCAdaptivePolicyCounters : public GCAdaptivePolicyCounters {
30 friend class VMStructs;
32 private:
34 // Capacity of tenured generation recorded at the end of
35 // any collection.
36 PerfVariable* _cms_capacity_counter; // Make this common with PS _old_capacity
38 // Average stop-the-world pause time for both initial and
39 // remark pauses sampled at the end of the checkpointRootsFinalWork.
40 PerfVariable* _avg_cms_STW_time_counter;
41 // Average stop-the-world (STW) GC cost for the STW pause time
42 // _avg_cms_STW_time_counter.
43 PerfVariable* _avg_cms_STW_gc_cost_counter;
45 #ifdef NOT_PRODUCT
46 // These are useful to see how the most recent values of these
47 // counters compare to their respective averages but
48 // do not control behavior.
49 PerfVariable* _initial_pause_counter;
50 PerfVariable* _remark_pause_counter;
51 #endif
53 // Average of the initial marking pause for a concurrent collection.
54 PerfVariable* _avg_initial_pause_counter;
55 // Average of the remark pause for a concurrent collection.
56 PerfVariable* _avg_remark_pause_counter;
58 // Average for the sum of all the concurrent times per collection.
59 PerfVariable* _avg_concurrent_time_counter;
60 // Average for the time between the most recent end of a
61 // concurrent collection and the beginning of the next
62 // concurrent collection.
63 PerfVariable* _avg_concurrent_interval_counter;
64 // Average of the concurrent GC costs based on _avg_concurrent_time_counter
65 // and _avg_concurrent_interval_counter.
66 PerfVariable* _avg_concurrent_gc_cost_counter;
68 // Average of the free space in the tenured generation at the
69 // end of the sweep of the tenured generation.
70 PerfVariable* _avg_cms_free_counter;
71 // Average of the free space in the tenured generation at the
72 // start of the sweep of the tenured genertion.
73 PerfVariable* _avg_cms_free_at_sweep_counter;
74 // Average of the free space in the tenured generation at the
75 // after any resizing of the tenured generation at the end
76 // of a collection of the tenured generation.
77 PerfVariable* _avg_cms_promo_counter;
79 // Average of the mark-sweep-compact (MSC) pause time for a collection
80 // of the tenured generation.
81 PerfVariable* _avg_msc_pause_counter;
82 // Average for the time between the most recent end of a
83 // MSC collection and the beginning of the next
84 // MSC collection.
85 PerfVariable* _avg_msc_interval_counter;
86 // Average for the GC cost of a MSC collection based on
87 // _avg_msc_pause_counter and _avg_msc_interval_counter.
88 PerfVariable* _msc_gc_cost_counter;
90 // Average of the mark-sweep (MS) pause time for a collection
91 // of the tenured generation.
92 PerfVariable* _avg_ms_pause_counter;
93 // Average for the time between the most recent end of a
94 // MS collection and the beginning of the next
95 // MS collection.
96 PerfVariable* _avg_ms_interval_counter;
97 // Average for the GC cost of a MS collection based on
98 // _avg_ms_pause_counter and _avg_ms_interval_counter.
99 PerfVariable* _ms_gc_cost_counter;
101 // Average of the bytes promoted per minor collection.
102 PerfVariable* _promoted_avg_counter;
103 // Average of the deviation of the promoted average
104 PerfVariable* _promoted_avg_dev_counter;
105 // Padded average of the bytes promoted per minor colleciton
106 PerfVariable* _promoted_padded_avg_counter;
108 // See description of the _change_young_gen_for_maj_pauses
109 // variable recently in cmsAdaptiveSizePolicy.hpp.
110 PerfVariable* _change_young_gen_for_maj_pauses_counter;
112 // See descriptions of _remark_pause_old_slope, _initial_pause_old_slope,
113 // etc. variables recently in cmsAdaptiveSizePolicy.hpp.
114 PerfVariable* _remark_pause_old_slope_counter;
115 PerfVariable* _initial_pause_old_slope_counter;
116 PerfVariable* _remark_pause_young_slope_counter;
117 PerfVariable* _initial_pause_young_slope_counter;
119 CMSAdaptiveSizePolicy* cms_size_policy() {
120 assert(_size_policy->kind() ==
121 AdaptiveSizePolicy::_gc_cms_adaptive_size_policy,
122 "Wrong size policy");
123 return (CMSAdaptiveSizePolicy*)_size_policy;
124 }
126 inline void update_avg_cms_STW_time_counter() {
127 _avg_cms_STW_time_counter->set_value(
128 (jlong) (cms_size_policy()->avg_cms_STW_time()->average() *
129 (double) MILLIUNITS));
130 }
132 inline void update_avg_cms_STW_gc_cost_counter() {
133 _avg_cms_STW_gc_cost_counter->set_value(
134 (jlong) (cms_size_policy()->avg_cms_STW_gc_cost()->average() * 100.0));
135 }
137 inline void update_avg_initial_pause_counter() {
138 _avg_initial_pause_counter->set_value(
139 (jlong) (cms_size_policy()->avg_initial_pause()->average() *
140 (double) MILLIUNITS));
141 }
142 #ifdef NOT_PRODUCT
143 inline void update_avg_remark_pause_counter() {
144 _avg_remark_pause_counter->set_value(
145 (jlong) (cms_size_policy()-> avg_remark_pause()->average() *
146 (double) MILLIUNITS));
147 }
149 inline void update_initial_pause_counter() {
150 _initial_pause_counter->set_value(
151 (jlong) (cms_size_policy()->avg_initial_pause()->average() *
152 (double) MILLIUNITS));
153 }
154 #endif
155 inline void update_remark_pause_counter() {
156 _remark_pause_counter->set_value(
157 (jlong) (cms_size_policy()-> avg_remark_pause()->last_sample() *
158 (double) MILLIUNITS));
159 }
161 inline void update_avg_concurrent_time_counter() {
162 _avg_concurrent_time_counter->set_value(
163 (jlong) (cms_size_policy()->avg_concurrent_time()->last_sample() *
164 (double) MILLIUNITS));
165 }
167 inline void update_avg_concurrent_interval_counter() {
168 _avg_concurrent_interval_counter->set_value(
169 (jlong) (cms_size_policy()->avg_concurrent_interval()->average() *
170 (double) MILLIUNITS));
171 }
173 inline void update_avg_concurrent_gc_cost_counter() {
174 _avg_concurrent_gc_cost_counter->set_value(
175 (jlong) (cms_size_policy()->avg_concurrent_gc_cost()->average() * 100.0));
176 }
178 inline void update_avg_cms_free_counter() {
179 _avg_cms_free_counter->set_value(
180 (jlong) cms_size_policy()->avg_cms_free()->average());
181 }
183 inline void update_avg_cms_free_at_sweep_counter() {
184 _avg_cms_free_at_sweep_counter->set_value(
185 (jlong) cms_size_policy()->avg_cms_free_at_sweep()->average());
186 }
188 inline void update_avg_cms_promo_counter() {
189 _avg_cms_promo_counter->set_value(
190 (jlong) cms_size_policy()->avg_cms_promo()->average());
191 }
193 inline void update_avg_old_live_counter() {
194 _avg_old_live_counter->set_value(
195 (jlong)(cms_size_policy()->avg_old_live()->average())
196 );
197 }
199 inline void update_avg_msc_pause_counter() {
200 _avg_msc_pause_counter->set_value(
201 (jlong) (cms_size_policy()->avg_msc_pause()->average() *
202 (double) MILLIUNITS));
203 }
205 inline void update_avg_msc_interval_counter() {
206 _avg_msc_interval_counter->set_value(
207 (jlong) (cms_size_policy()->avg_msc_interval()->average() *
208 (double) MILLIUNITS));
209 }
211 inline void update_msc_gc_cost_counter() {
212 _msc_gc_cost_counter->set_value(
213 (jlong) (cms_size_policy()->avg_msc_gc_cost()->average() * 100.0));
214 }
216 inline void update_avg_ms_pause_counter() {
217 _avg_ms_pause_counter->set_value(
218 (jlong) (cms_size_policy()->avg_ms_pause()->average() *
219 (double) MILLIUNITS));
220 }
222 inline void update_avg_ms_interval_counter() {
223 _avg_ms_interval_counter->set_value(
224 (jlong) (cms_size_policy()->avg_ms_interval()->average() *
225 (double) MILLIUNITS));
226 }
228 inline void update_ms_gc_cost_counter() {
229 _ms_gc_cost_counter->set_value(
230 (jlong) (cms_size_policy()->avg_ms_gc_cost()->average() * 100.0));
231 }
233 inline void update_major_gc_cost_counter() {
234 _major_gc_cost_counter->set_value(
235 (jlong)(cms_size_policy()->cms_gc_cost() * 100.0)
236 );
237 }
238 inline void update_mutator_cost_counter() {
239 _mutator_cost_counter->set_value(
240 (jlong)(cms_size_policy()->mutator_cost() * 100.0)
241 );
242 }
244 inline void update_avg_promoted_avg(CMSGCStats* gc_stats) {
245 _promoted_avg_counter->set_value(
246 (jlong)(gc_stats->avg_promoted()->average())
247 );
248 }
249 inline void update_avg_promoted_dev(CMSGCStats* gc_stats) {
250 _promoted_avg_dev_counter->set_value(
251 (jlong)(gc_stats->avg_promoted()->deviation())
252 );
253 }
254 inline void update_avg_promoted_padded_avg(CMSGCStats* gc_stats) {
255 _promoted_padded_avg_counter->set_value(
256 (jlong)(gc_stats->avg_promoted()->padded_average())
257 );
258 }
259 inline void update_remark_pause_old_slope_counter() {
260 _remark_pause_old_slope_counter->set_value(
261 (jlong)(cms_size_policy()->remark_pause_old_slope() * 1000)
262 );
263 }
264 inline void update_initial_pause_old_slope_counter() {
265 _initial_pause_old_slope_counter->set_value(
266 (jlong)(cms_size_policy()->initial_pause_old_slope() * 1000)
267 );
268 }
269 inline void update_remark_pause_young_slope_counter() {
270 _remark_pause_young_slope_counter->set_value(
271 (jlong)(cms_size_policy()->remark_pause_young_slope() * 1000)
272 );
273 }
274 inline void update_initial_pause_young_slope_counter() {
275 _initial_pause_young_slope_counter->set_value(
276 (jlong)(cms_size_policy()->initial_pause_young_slope() * 1000)
277 );
278 }
279 inline void update_change_young_gen_for_maj_pauses() {
280 _change_young_gen_for_maj_pauses_counter->set_value(
281 cms_size_policy()->change_young_gen_for_maj_pauses());
282 }
284 public:
285 CMSGCAdaptivePolicyCounters(const char* name, int collectors, int generations,
286 AdaptiveSizePolicy* size_policy);
288 // update counters
289 void update_counters();
290 void update_counters(CMSGCStats* gc_stats);
291 void update_counters_from_policy();
293 inline void update_cms_capacity_counter(size_t size_in_bytes) {
294 _cms_capacity_counter->set_value(size_in_bytes);
295 }
297 virtual GCPolicyCounters::Name kind() const {
298 return GCPolicyCounters::CMSGCAdaptivePolicyCountersKind;
299 }
300 };