Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp @ 10374:87c64c0438fb
6976350: G1: deal with fragmentation while copying objects during GC
Summary: Create G1ParGCAllocBufferContainer to contain two buffers instead of previously using one buffer, in order to hold the first priority buffer longer. Thus, when some large objects hits the value of free space left in the first priority buffer it has an alternative to fit in the second priority buffer while the first priority buffer is given more chances to try allocating smaller objects. Overall, it will improve heap space efficiency.
Reviewed-by: johnc, jmasa, brutisso
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Mon, 03 Jun 2013 14:37:13 -0700 |
| parents | db9981fd3124 |
| children | de6a9e811145 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
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:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_GCADAPTIVEPOLICYCOUNTERS_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_GCADAPTIVEPOLICYCOUNTERS_HPP | |
| 27 | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6818
diff
changeset
|
28 #include "utilities/macros.hpp" |
|
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6818
diff
changeset
|
29 #if INCLUDE_ALL_GCS |
| 1972 | 30 #include "gc_implementation/shared/adaptiveSizePolicy.hpp" |
| 31 #include "gc_implementation/shared/gcPolicyCounters.hpp" | |
|
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6818
diff
changeset
|
32 #endif // INCLUDE_ALL_GCS |
| 1972 | 33 |
| 0 | 34 // This class keeps statistical information and computes the |
| 35 // size of the heap. | |
| 36 | |
| 37 class GCAdaptivePolicyCounters : public GCPolicyCounters { | |
| 38 protected: | |
| 39 PerfVariable* _eden_size_counter; | |
| 40 PerfVariable* _promo_size_counter; | |
| 41 | |
| 42 PerfVariable* _young_capacity_counter; | |
| 43 | |
| 44 PerfVariable* _minor_gc_cost_counter; | |
| 45 PerfVariable* _major_gc_cost_counter; | |
| 46 PerfVariable* _mutator_cost_counter; | |
| 47 | |
| 48 PerfVariable* _avg_young_live_counter; | |
| 49 PerfVariable* _avg_old_live_counter; | |
| 50 | |
| 51 PerfVariable* _avg_minor_pause_counter; | |
| 52 PerfVariable* _avg_minor_interval_counter; | |
| 53 | |
| 54 #ifdef NOT_PRODUCT | |
| 55 PerfVariable* _minor_pause_counter; | |
| 56 #endif | |
| 57 | |
| 58 PerfVariable* _change_young_gen_for_min_pauses_counter; | |
| 59 PerfVariable* _change_young_gen_for_throughput_counter; | |
| 60 PerfVariable* _change_old_gen_for_maj_pauses_counter; | |
| 61 PerfVariable* _change_old_gen_for_throughput_counter; | |
| 62 PerfVariable* _decrease_for_footprint_counter; | |
| 63 | |
| 64 PerfVariable* _minor_pause_young_slope_counter; | |
| 65 PerfVariable* _major_pause_old_slope_counter; | |
| 66 | |
| 67 PerfVariable* _decide_at_full_gc_counter; | |
| 68 | |
| 69 PerfVariable* _survived_counter; | |
| 70 PerfVariable* _promoted_counter; | |
| 71 | |
| 72 PerfVariable* _avg_survived_avg_counter; | |
| 73 PerfVariable* _avg_survived_dev_counter; | |
| 74 PerfVariable* _avg_survived_padded_avg_counter; | |
| 75 | |
| 76 PerfVariable* _survivor_overflowed_counter; | |
| 77 PerfVariable* _increment_tenuring_threshold_for_gc_cost_counter; | |
| 78 PerfVariable* _decrement_tenuring_threshold_for_gc_cost_counter; | |
| 79 PerfVariable* _decrement_tenuring_threshold_for_survivor_limit_counter; | |
| 80 | |
| 81 PerfVariable* _minor_collection_slope_counter; | |
| 82 PerfVariable* _major_collection_slope_counter; | |
| 83 | |
| 84 AdaptiveSizePolicy* _size_policy; | |
| 85 | |
| 86 inline void update_eden_size() { | |
| 87 size_t eden_size_in_bytes = size_policy()->calculated_eden_size_in_bytes(); | |
| 88 _eden_size_counter->set_value(eden_size_in_bytes); | |
| 89 } | |
| 90 | |
| 91 inline void update_promo_size() { | |
| 92 _promo_size_counter->set_value( | |
| 93 size_policy()->calculated_promo_size_in_bytes()); | |
| 94 } | |
| 95 | |
| 96 inline void update_avg_minor_pause_counter() { | |
| 97 _avg_minor_pause_counter->set_value((jlong) | |
| 98 (size_policy()->avg_minor_pause()->average() * 1000.0)); | |
| 99 } | |
| 100 inline void update_avg_minor_interval_counter() { | |
| 101 _avg_minor_interval_counter->set_value((jlong) | |
| 102 (size_policy()->avg_minor_interval()->average() * 1000.0)); | |
| 103 } | |
| 104 | |
| 105 #ifdef NOT_PRODUCT | |
| 106 inline void update_minor_pause_counter() { | |
| 107 _minor_pause_counter->set_value((jlong) | |
| 108 (size_policy()->avg_minor_pause()->last_sample() * 1000.0)); | |
| 109 } | |
| 110 #endif | |
| 111 inline void update_minor_gc_cost_counter() { | |
| 112 _minor_gc_cost_counter->set_value((jlong) | |
| 113 (size_policy()->minor_gc_cost() * 100.0)); | |
| 114 } | |
| 115 | |
| 116 inline void update_avg_young_live_counter() { | |
| 117 _avg_young_live_counter->set_value( | |
| 118 (jlong)(size_policy()->avg_young_live()->average()) | |
| 119 ); | |
| 120 } | |
| 121 | |
| 122 inline void update_avg_survived_avg_counters() { | |
| 123 _avg_survived_avg_counter->set_value( | |
| 124 (jlong)(size_policy()->_avg_survived->average()) | |
| 125 ); | |
| 126 } | |
| 127 inline void update_avg_survived_dev_counters() { | |
| 128 _avg_survived_dev_counter->set_value( | |
| 129 (jlong)(size_policy()->_avg_survived->deviation()) | |
| 130 ); | |
| 131 } | |
| 132 inline void update_avg_survived_padded_avg_counters() { | |
| 133 _avg_survived_padded_avg_counter->set_value( | |
| 134 (jlong)(size_policy()->_avg_survived->padded_average()) | |
| 135 ); | |
| 136 } | |
| 137 | |
| 138 inline void update_change_old_gen_for_throughput() { | |
| 139 _change_old_gen_for_throughput_counter->set_value( | |
| 140 size_policy()->change_old_gen_for_throughput()); | |
| 141 } | |
| 142 inline void update_change_young_gen_for_throughput() { | |
| 143 _change_young_gen_for_throughput_counter->set_value( | |
| 144 size_policy()->change_young_gen_for_throughput()); | |
| 145 } | |
| 146 inline void update_decrease_for_footprint() { | |
| 147 _decrease_for_footprint_counter->set_value( | |
| 148 size_policy()->decrease_for_footprint()); | |
| 149 } | |
| 150 | |
| 151 inline void update_decide_at_full_gc_counter() { | |
| 152 _decide_at_full_gc_counter->set_value( | |
| 153 size_policy()->decide_at_full_gc()); | |
| 154 } | |
| 155 | |
| 156 inline void update_minor_pause_young_slope_counter() { | |
| 157 _minor_pause_young_slope_counter->set_value( | |
| 158 (jlong)(size_policy()->minor_pause_young_slope() * 1000) | |
| 159 ); | |
| 160 } | |
| 161 | |
| 162 virtual void update_counters_from_policy(); | |
| 163 | |
| 164 protected: | |
| 165 virtual AdaptiveSizePolicy* size_policy() { return _size_policy; } | |
| 166 | |
| 167 public: | |
| 168 GCAdaptivePolicyCounters(const char* name, | |
| 169 int collectors, | |
| 170 int generations, | |
| 171 AdaptiveSizePolicy* size_policy); | |
| 172 | |
| 173 inline void update_survived(size_t survived) { | |
| 174 _survived_counter->set_value(survived); | |
| 175 } | |
| 176 inline void update_promoted(size_t promoted) { | |
| 177 _promoted_counter->set_value(promoted); | |
| 178 } | |
| 179 inline void update_young_capacity(size_t size_in_bytes) { | |
| 180 _young_capacity_counter->set_value(size_in_bytes); | |
| 181 } | |
| 182 | |
| 183 virtual void update_counters(); | |
| 184 | |
| 185 inline void update_survivor_size_counters() { | |
| 186 desired_survivor_size()->set_value( | |
| 187 size_policy()->calculated_survivor_size_in_bytes()); | |
| 188 } | |
| 189 inline void update_survivor_overflowed(bool survivor_overflowed) { | |
| 190 _survivor_overflowed_counter->set_value(survivor_overflowed); | |
| 191 } | |
| 6818 | 192 inline void update_tenuring_threshold(uint threshold) { |
| 0 | 193 tenuring_threshold()->set_value(threshold); |
| 194 } | |
| 195 inline void update_increment_tenuring_threshold_for_gc_cost() { | |
| 196 _increment_tenuring_threshold_for_gc_cost_counter->set_value( | |
| 197 size_policy()->increment_tenuring_threshold_for_gc_cost()); | |
| 198 } | |
| 199 inline void update_decrement_tenuring_threshold_for_gc_cost() { | |
| 200 _decrement_tenuring_threshold_for_gc_cost_counter->set_value( | |
| 201 size_policy()->decrement_tenuring_threshold_for_gc_cost()); | |
| 202 } | |
| 203 inline void update_decrement_tenuring_threshold_for_survivor_limit() { | |
| 204 _decrement_tenuring_threshold_for_survivor_limit_counter->set_value( | |
| 205 size_policy()->decrement_tenuring_threshold_for_survivor_limit()); | |
| 206 } | |
| 207 inline void update_change_young_gen_for_min_pauses() { | |
| 208 _change_young_gen_for_min_pauses_counter->set_value( | |
| 209 size_policy()->change_young_gen_for_min_pauses()); | |
| 210 } | |
| 211 inline void update_change_old_gen_for_maj_pauses() { | |
| 212 _change_old_gen_for_maj_pauses_counter->set_value( | |
| 213 size_policy()->change_old_gen_for_maj_pauses()); | |
| 214 } | |
| 215 | |
| 216 inline void update_minor_collection_slope_counter() { | |
| 217 _minor_collection_slope_counter->set_value( | |
| 218 (jlong)(size_policy()->minor_collection_slope() * 1000) | |
| 219 ); | |
| 220 } | |
| 221 | |
| 222 inline void update_major_collection_slope_counter() { | |
| 223 _major_collection_slope_counter->set_value( | |
| 224 (jlong)(size_policy()->major_collection_slope() * 1000) | |
| 225 ); | |
| 226 } | |
| 227 | |
| 228 void set_size_policy(AdaptiveSizePolicy* v) { _size_policy = v; } | |
| 229 | |
| 230 virtual GCPolicyCounters::Name kind() const { | |
| 231 return GCPolicyCounters::GCAdaptivePolicyCountersKind; | |
| 232 } | |
| 233 }; | |
| 1972 | 234 |
| 235 #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_GCADAPTIVEPOLICYCOUNTERS_HPP |