Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/survRateGroup.cpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
| author | tschatzl |
|---|---|
| date | Wed, 11 Sep 2013 16:25:02 +0200 |
| parents | d2a62e0f25eb |
| children | 78bbf4d43a14 |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 5938 | 2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
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:
1394
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 27 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
| 28 #include "gc_implementation/g1/heapRegion.hpp" | |
| 29 #include "gc_implementation/g1/survRateGroup.hpp" | |
| 30 #include "memory/allocation.hpp" | |
| 342 | 31 |
| 32 SurvRateGroup::SurvRateGroup(G1CollectorPolicy* g1p, | |
| 33 const char* name, | |
| 34 size_t summary_surv_rates_len) : | |
| 35 _g1p(g1p), _name(name), | |
| 36 _summary_surv_rates_len(summary_surv_rates_len), | |
| 37 _summary_surv_rates_max_len(0), | |
| 545 | 38 _summary_surv_rates(NULL), |
| 39 _surv_rate(NULL), | |
| 40 _accum_surv_rate_pred(NULL), | |
| 5938 | 41 _surv_rate_pred(NULL), |
| 42 _stats_arrays_length(0) { | |
| 545 | 43 reset(); |
| 342 | 44 if (summary_surv_rates_len > 0) { |
| 45 size_t length = summary_surv_rates_len; | |
| 6197 | 46 _summary_surv_rates = NEW_C_HEAP_ARRAY(NumberSeq*, length, mtGC); |
| 5938 | 47 for (size_t i = 0; i < length; ++i) { |
| 48 _summary_surv_rates[i] = new NumberSeq(); | |
| 342 | 49 } |
| 50 } | |
| 51 | |
| 52 start_adding_regions(); | |
| 53 } | |
| 54 | |
| 5938 | 55 void SurvRateGroup::reset() { |
| 545 | 56 _all_regions_allocated = 0; |
| 57 _setup_seq_num = 0; | |
| 58 _accum_surv_rate = 0.0; | |
| 59 _last_pred = 0.0; | |
| 60 // the following will set up the arrays with length 1 | |
| 61 _region_num = 1; | |
| 5938 | 62 |
| 63 // The call to stop_adding_regions() will use "new" to refill | |
| 64 // the _surv_rate_pred array, so we need to make sure to call | |
| 65 // "delete". | |
| 66 for (size_t i = 0; i < _stats_arrays_length; ++i) { | |
| 67 delete _surv_rate_pred[i]; | |
| 68 } | |
| 69 _stats_arrays_length = 0; | |
| 70 | |
| 545 | 71 stop_adding_regions(); |
| 72 guarantee( _stats_arrays_length == 1, "invariant" ); | |
| 73 guarantee( _surv_rate_pred[0] != NULL, "invariant" ); | |
| 74 _surv_rate_pred[0]->add(0.4); | |
| 75 all_surviving_words_recorded(false); | |
| 76 _region_num = 0; | |
| 77 } | |
| 78 | |
| 342 | 79 void |
| 80 SurvRateGroup::start_adding_regions() { | |
| 545 | 81 _setup_seq_num = _stats_arrays_length; |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
579
diff
changeset
|
82 _region_num = 0; |
| 342 | 83 _accum_surv_rate = 0.0; |
| 84 } | |
| 85 | |
| 86 void | |
| 87 SurvRateGroup::stop_adding_regions() { | |
| 545 | 88 if (_region_num > _stats_arrays_length) { |
| 342 | 89 double* old_surv_rate = _surv_rate; |
| 90 double* old_accum_surv_rate_pred = _accum_surv_rate_pred; | |
| 91 TruncatedSeq** old_surv_rate_pred = _surv_rate_pred; | |
| 92 | |
| 6197 | 93 _surv_rate = NEW_C_HEAP_ARRAY(double, _region_num, mtGC); |
| 94 _accum_surv_rate_pred = NEW_C_HEAP_ARRAY(double, _region_num, mtGC); | |
| 95 _surv_rate_pred = NEW_C_HEAP_ARRAY(TruncatedSeq*, _region_num, mtGC); | |
| 342 | 96 |
| 5938 | 97 for (size_t i = 0; i < _stats_arrays_length; ++i) { |
| 342 | 98 _surv_rate_pred[i] = old_surv_rate_pred[i]; |
| 5938 | 99 } |
| 545 | 100 for (size_t i = _stats_arrays_length; i < _region_num; ++i) { |
| 342 | 101 _surv_rate_pred[i] = new TruncatedSeq(10); |
| 102 } | |
| 103 | |
| 545 | 104 _stats_arrays_length = _region_num; |
| 342 | 105 |
| 5938 | 106 if (old_surv_rate != NULL) { |
| 6197 | 107 FREE_C_HEAP_ARRAY(double, old_surv_rate, mtGC); |
| 5938 | 108 } |
| 109 if (old_accum_surv_rate_pred != NULL) { | |
| 6197 | 110 FREE_C_HEAP_ARRAY(double, old_accum_surv_rate_pred, mtGC); |
| 5938 | 111 } |
| 112 if (old_surv_rate_pred != NULL) { | |
| 6197 | 113 FREE_C_HEAP_ARRAY(TruncatedSeq*, old_surv_rate_pred, mtGC); |
| 5938 | 114 } |
| 342 | 115 } |
| 116 | |
| 5938 | 117 for (size_t i = 0; i < _stats_arrays_length; ++i) { |
| 342 | 118 _surv_rate[i] = 0.0; |
| 5938 | 119 } |
| 342 | 120 } |
| 121 | |
| 122 double | |
| 123 SurvRateGroup::accum_surv_rate(size_t adjustment) { | |
| 124 // we might relax this one in the future... | |
| 125 guarantee( adjustment == 0 || adjustment == 1, "pre-condition" ); | |
| 126 | |
| 127 double ret = _accum_surv_rate; | |
| 128 if (adjustment > 0) { | |
| 545 | 129 TruncatedSeq* seq = get_seq(_region_num+1); |
| 342 | 130 double surv_rate = _g1p->get_new_prediction(seq); |
| 131 ret += surv_rate; | |
| 132 } | |
| 133 | |
| 134 return ret; | |
| 135 } | |
| 136 | |
| 137 int | |
| 138 SurvRateGroup::next_age_index() { | |
| 545 | 139 TruncatedSeq* seq = get_seq(_region_num); |
| 342 | 140 double surv_rate = _g1p->get_new_prediction(seq); |
| 141 _accum_surv_rate += surv_rate; | |
| 142 | |
| 545 | 143 ++_region_num; |
| 342 | 144 return (int) ++_all_regions_allocated; |
| 145 } | |
| 146 | |
| 147 void | |
| 148 SurvRateGroup::record_surviving_words(int age_in_group, size_t surv_words) { | |
| 545 | 149 guarantee( 0 <= age_in_group && (size_t) age_in_group < _region_num, |
| 342 | 150 "pre-condition" ); |
| 151 guarantee( _surv_rate[age_in_group] <= 0.00001, | |
| 152 "should only update each slot once" ); | |
| 153 | |
| 154 double surv_rate = (double) surv_words / (double) HeapRegion::GrainWords; | |
| 155 _surv_rate[age_in_group] = surv_rate; | |
| 156 _surv_rate_pred[age_in_group]->add(surv_rate); | |
| 157 if ((size_t)age_in_group < _summary_surv_rates_len) { | |
| 158 _summary_surv_rates[age_in_group]->add(surv_rate); | |
| 159 if ((size_t)(age_in_group+1) > _summary_surv_rates_max_len) | |
| 160 _summary_surv_rates_max_len = age_in_group+1; | |
| 161 } | |
| 162 } | |
| 163 | |
| 164 void | |
| 165 SurvRateGroup::all_surviving_words_recorded(bool propagate) { | |
| 545 | 166 if (propagate && _region_num > 0) { // conservative |
| 167 double surv_rate = _surv_rate_pred[_region_num-1]->last(); | |
| 168 for (size_t i = _region_num; i < _stats_arrays_length; ++i) { | |
| 342 | 169 guarantee( _surv_rate[i] <= 0.00001, |
| 170 "the slot should not have been updated" ); | |
| 171 _surv_rate_pred[i]->add(surv_rate); | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 double accum = 0.0; | |
| 176 double pred = 0.0; | |
| 545 | 177 for (size_t i = 0; i < _stats_arrays_length; ++i) { |
| 342 | 178 pred = _g1p->get_new_prediction(_surv_rate_pred[i]); |
| 179 if (pred > 1.0) pred = 1.0; | |
| 180 accum += pred; | |
| 181 _accum_surv_rate_pred[i] = accum; | |
| 182 // gclog_or_tty->print_cr("age %3d, accum %10.2lf", i, accum); | |
| 183 } | |
| 184 _last_pred = pred; | |
| 185 } | |
| 186 | |
| 187 #ifndef PRODUCT | |
| 188 void | |
| 189 SurvRateGroup::print() { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
579
diff
changeset
|
190 gclog_or_tty->print_cr("Surv Rate Group: %s (%d entries)", |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
579
diff
changeset
|
191 _name, _region_num); |
| 545 | 192 for (size_t i = 0; i < _region_num; ++i) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
579
diff
changeset
|
193 gclog_or_tty->print_cr(" age %4d surv rate %6.2lf %% pred %6.2lf %%", |
| 342 | 194 i, _surv_rate[i] * 100.0, |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
579
diff
changeset
|
195 _g1p->get_new_prediction(_surv_rate_pred[i]) * 100.0); |
| 342 | 196 } |
| 197 } | |
| 198 | |
| 199 void | |
| 200 SurvRateGroup::print_surv_rate_summary() { | |
| 201 size_t length = _summary_surv_rates_max_len; | |
| 202 if (length == 0) | |
| 203 return; | |
| 204 | |
| 205 gclog_or_tty->print_cr(""); | |
| 206 gclog_or_tty->print_cr("%s Rate Summary (for up to age %d)", _name, length-1); | |
| 207 gclog_or_tty->print_cr(" age range survival rate (avg) samples (avg)"); | |
| 208 gclog_or_tty->print_cr(" ---------------------------------------------------------"); | |
| 209 | |
| 210 size_t index = 0; | |
| 211 size_t limit = MIN2((int) length, 10); | |
| 212 while (index < limit) { | |
| 213 gclog_or_tty->print_cr(" %4d %6.2lf%% %6.2lf", | |
| 214 index, _summary_surv_rates[index]->avg() * 100.0, | |
| 215 (double) _summary_surv_rates[index]->num()); | |
| 216 ++index; | |
| 217 } | |
| 218 | |
| 219 gclog_or_tty->print_cr(" ---------------------------------------------------------"); | |
| 220 | |
| 221 int num = 0; | |
| 222 double sum = 0.0; | |
| 223 int samples = 0; | |
| 224 while (index < length) { | |
| 225 ++num; | |
| 226 sum += _summary_surv_rates[index]->avg() * 100.0; | |
| 227 samples += _summary_surv_rates[index]->num(); | |
| 228 ++index; | |
| 229 | |
| 230 if (index == length || num % 10 == 0) { | |
| 231 gclog_or_tty->print_cr(" %4d .. %4d %6.2lf%% %6.2lf", | |
| 232 (index-1) / 10 * 10, index-1, sum / (double) num, | |
| 233 (double) samples / (double) num); | |
| 234 sum = 0.0; | |
| 235 num = 0; | |
| 236 samples = 0; | |
| 237 } | |
| 238 } | |
| 239 | |
| 240 gclog_or_tty->print_cr(" ---------------------------------------------------------"); | |
| 241 } | |
| 242 #endif // PRODUCT |