Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/survRateGroup.cpp @ 545:58054a18d735

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6484959: G1: introduce survivor spaces 6797754: G1: combined bugfix Summary: Implemented a policy to control G1 survivor space parameters. Reviewed-by: tonyp, iveresov
author apetrusenko
date Fri, 06 Feb 2009 01:38:50 +0300
parents 37f87013dfd8
children 0fbdb4381b99
comparison
equal deleted inserted replaced
544:82a980778b92 545:58054a18d735
27 27
28 SurvRateGroup::SurvRateGroup(G1CollectorPolicy* g1p, 28 SurvRateGroup::SurvRateGroup(G1CollectorPolicy* g1p,
29 const char* name, 29 const char* name,
30 size_t summary_surv_rates_len) : 30 size_t summary_surv_rates_len) :
31 _g1p(g1p), _name(name), 31 _g1p(g1p), _name(name),
32 _all_regions_allocated(0),
33 _curr_length(0), _scan_only_prefix(0), _setup_seq_num(0),
34 _array_length(0), _surv_rate(NULL), _accum_surv_rate_pred(NULL),
35 _accum_surv_rate(0.0), _surv_rate_pred(NULL), _last_pred(0.0),
36 _summary_surv_rates_len(summary_surv_rates_len), 32 _summary_surv_rates_len(summary_surv_rates_len),
37 _summary_surv_rates_max_len(0), 33 _summary_surv_rates_max_len(0),
38 _summary_surv_rates(NULL) { 34 _summary_surv_rates(NULL),
39 35 _surv_rate(NULL),
40 // the following will set up the arrays with length 1 36 _accum_surv_rate_pred(NULL),
41 _curr_length = 1; 37 _surv_rate_pred(NULL)
42 stop_adding_regions(); 38 {
43 guarantee( _array_length == 1, "invariant" ); 39 reset();
44 guarantee( _surv_rate_pred[0] != NULL, "invariant" );
45 _surv_rate_pred[0]->add(0.4);
46 all_surviving_words_recorded(false);
47 _curr_length = 0;
48
49 if (summary_surv_rates_len > 0) { 40 if (summary_surv_rates_len > 0) {
50 size_t length = summary_surv_rates_len; 41 size_t length = summary_surv_rates_len;
51 _summary_surv_rates = NEW_C_HEAP_ARRAY(NumberSeq*, length); 42 _summary_surv_rates = NEW_C_HEAP_ARRAY(NumberSeq*, length);
52 if (_summary_surv_rates == NULL) { 43 if (_summary_surv_rates == NULL) {
53 vm_exit_out_of_memory(sizeof(NumberSeq*) * length, 44 vm_exit_out_of_memory(sizeof(NumberSeq*) * length,
58 } 49 }
59 50
60 start_adding_regions(); 51 start_adding_regions();
61 } 52 }
62 53
54
55 void SurvRateGroup::reset()
56 {
57 _all_regions_allocated = 0;
58 _scan_only_prefix = 0;
59 _setup_seq_num = 0;
60 _stats_arrays_length = 0;
61 _accum_surv_rate = 0.0;
62 _last_pred = 0.0;
63 // the following will set up the arrays with length 1
64 _region_num = 1;
65 stop_adding_regions();
66 guarantee( _stats_arrays_length == 1, "invariant" );
67 guarantee( _surv_rate_pred[0] != NULL, "invariant" );
68 _surv_rate_pred[0]->add(0.4);
69 all_surviving_words_recorded(false);
70 _region_num = 0;
71 }
72
73
63 void 74 void
64 SurvRateGroup::start_adding_regions() { 75 SurvRateGroup::start_adding_regions() {
65 _setup_seq_num = _array_length; 76 _setup_seq_num = _stats_arrays_length;
66 _curr_length = _scan_only_prefix; 77 _region_num = _scan_only_prefix;
67 _accum_surv_rate = 0.0; 78 _accum_surv_rate = 0.0;
68 79
69 #if 0 80 #if 0
70 gclog_or_tty->print_cr("start adding regions, seq num %d, length %d", 81 gclog_or_tty->print_cr("[%s] start adding regions, seq num %d, length %d",
71 _setup_seq_num, _curr_length); 82 _name, _setup_seq_num, _region_num);
72 #endif // 0 83 #endif // 0
73 } 84 }
74 85
75 void 86 void
76 SurvRateGroup::stop_adding_regions() { 87 SurvRateGroup::stop_adding_regions() {
77 size_t length = _curr_length; 88
78 89 #if 0
79 #if 0 90 gclog_or_tty->print_cr("[%s] stop adding regions, length %d", _name, _region_num);
80 gclog_or_tty->print_cr("stop adding regions, length %d", length); 91 #endif // 0
81 #endif // 0 92
82 93 if (_region_num > _stats_arrays_length) {
83 if (length > _array_length) {
84 double* old_surv_rate = _surv_rate; 94 double* old_surv_rate = _surv_rate;
85 double* old_accum_surv_rate_pred = _accum_surv_rate_pred; 95 double* old_accum_surv_rate_pred = _accum_surv_rate_pred;
86 TruncatedSeq** old_surv_rate_pred = _surv_rate_pred; 96 TruncatedSeq** old_surv_rate_pred = _surv_rate_pred;
87 97
88 _surv_rate = NEW_C_HEAP_ARRAY(double, length); 98 _surv_rate = NEW_C_HEAP_ARRAY(double, _region_num);
89 if (_surv_rate == NULL) { 99 if (_surv_rate == NULL) {
90 vm_exit_out_of_memory(sizeof(double) * length, 100 vm_exit_out_of_memory(sizeof(double) * _region_num,
91 "Not enough space for surv rate array."); 101 "Not enough space for surv rate array.");
92 } 102 }
93 _accum_surv_rate_pred = NEW_C_HEAP_ARRAY(double, length); 103 _accum_surv_rate_pred = NEW_C_HEAP_ARRAY(double, _region_num);
94 if (_accum_surv_rate_pred == NULL) { 104 if (_accum_surv_rate_pred == NULL) {
95 vm_exit_out_of_memory(sizeof(double) * length, 105 vm_exit_out_of_memory(sizeof(double) * _region_num,
96 "Not enough space for accum surv rate pred array."); 106 "Not enough space for accum surv rate pred array.");
97 } 107 }
98 _surv_rate_pred = NEW_C_HEAP_ARRAY(TruncatedSeq*, length); 108 _surv_rate_pred = NEW_C_HEAP_ARRAY(TruncatedSeq*, _region_num);
99 if (_surv_rate == NULL) { 109 if (_surv_rate == NULL) {
100 vm_exit_out_of_memory(sizeof(TruncatedSeq*) * length, 110 vm_exit_out_of_memory(sizeof(TruncatedSeq*) * _region_num,
101 "Not enough space for surv rate pred array."); 111 "Not enough space for surv rate pred array.");
102 } 112 }
103 113
104 for (size_t i = 0; i < _array_length; ++i) 114 for (size_t i = 0; i < _stats_arrays_length; ++i)
105 _surv_rate_pred[i] = old_surv_rate_pred[i]; 115 _surv_rate_pred[i] = old_surv_rate_pred[i];
106 116
107 #if 0 117 #if 0
108 gclog_or_tty->print_cr("stop adding regions, new seqs %d to %d", 118 gclog_or_tty->print_cr("[%s] stop adding regions, new seqs %d to %d",
109 _array_length, length - 1); 119 _name, _array_length, _region_num - 1);
110 #endif // 0 120 #endif // 0
111 121
112 for (size_t i = _array_length; i < length; ++i) { 122 for (size_t i = _stats_arrays_length; i < _region_num; ++i) {
113 _surv_rate_pred[i] = new TruncatedSeq(10); 123 _surv_rate_pred[i] = new TruncatedSeq(10);
114 // _surv_rate_pred[i]->add(last_pred); 124 // _surv_rate_pred[i]->add(last_pred);
115 } 125 }
116 126
117 _array_length = length; 127 _stats_arrays_length = _region_num;
118 128
119 if (old_surv_rate != NULL) 129 if (old_surv_rate != NULL)
120 FREE_C_HEAP_ARRAY(double, old_surv_rate); 130 FREE_C_HEAP_ARRAY(double, old_surv_rate);
121 if (old_accum_surv_rate_pred != NULL) 131 if (old_accum_surv_rate_pred != NULL)
122 FREE_C_HEAP_ARRAY(double, old_accum_surv_rate_pred); 132 FREE_C_HEAP_ARRAY(double, old_accum_surv_rate_pred);
123 if (old_surv_rate_pred != NULL) 133 if (old_surv_rate_pred != NULL)
124 FREE_C_HEAP_ARRAY(NumberSeq*, old_surv_rate_pred); 134 FREE_C_HEAP_ARRAY(NumberSeq*, old_surv_rate_pred);
125 } 135 }
126 136
127 for (size_t i = 0; i < _array_length; ++i) 137 for (size_t i = 0; i < _stats_arrays_length; ++i)
128 _surv_rate[i] = 0.0; 138 _surv_rate[i] = 0.0;
129 } 139 }
130 140
131 double 141 double
132 SurvRateGroup::accum_surv_rate(size_t adjustment) { 142 SurvRateGroup::accum_surv_rate(size_t adjustment) {
133 // we might relax this one in the future... 143 // we might relax this one in the future...
134 guarantee( adjustment == 0 || adjustment == 1, "pre-condition" ); 144 guarantee( adjustment == 0 || adjustment == 1, "pre-condition" );
135 145
136 double ret = _accum_surv_rate; 146 double ret = _accum_surv_rate;
137 if (adjustment > 0) { 147 if (adjustment > 0) {
138 TruncatedSeq* seq = get_seq(_curr_length+1); 148 TruncatedSeq* seq = get_seq(_region_num+1);
139 double surv_rate = _g1p->get_new_prediction(seq); 149 double surv_rate = _g1p->get_new_prediction(seq);
140 ret += surv_rate; 150 ret += surv_rate;
141 } 151 }
142 152
143 return ret; 153 return ret;
144 } 154 }
145 155
146 int 156 int
147 SurvRateGroup::next_age_index() { 157 SurvRateGroup::next_age_index() {
148 TruncatedSeq* seq = get_seq(_curr_length); 158 TruncatedSeq* seq = get_seq(_region_num);
149 double surv_rate = _g1p->get_new_prediction(seq); 159 double surv_rate = _g1p->get_new_prediction(seq);
150 _accum_surv_rate += surv_rate; 160 _accum_surv_rate += surv_rate;
151 161
152 ++_curr_length; 162 ++_region_num;
153 return (int) ++_all_regions_allocated; 163 return (int) ++_all_regions_allocated;
154 } 164 }
155 165
156 void 166 void
157 SurvRateGroup::record_scan_only_prefix(size_t scan_only_prefix) { 167 SurvRateGroup::record_scan_only_prefix(size_t scan_only_prefix) {
158 guarantee( scan_only_prefix <= _curr_length, "pre-condition" ); 168 guarantee( scan_only_prefix <= _region_num, "pre-condition" );
159 _scan_only_prefix = scan_only_prefix; 169 _scan_only_prefix = scan_only_prefix;
160 } 170 }
161 171
162 void 172 void
163 SurvRateGroup::record_surviving_words(int age_in_group, size_t surv_words) { 173 SurvRateGroup::record_surviving_words(int age_in_group, size_t surv_words) {
164 guarantee( 0 <= age_in_group && (size_t) age_in_group < _curr_length, 174 guarantee( 0 <= age_in_group && (size_t) age_in_group < _region_num,
165 "pre-condition" ); 175 "pre-condition" );
166 guarantee( _surv_rate[age_in_group] <= 0.00001, 176 guarantee( _surv_rate[age_in_group] <= 0.00001,
167 "should only update each slot once" ); 177 "should only update each slot once" );
168 178
169 double surv_rate = (double) surv_words / (double) HeapRegion::GrainWords; 179 double surv_rate = (double) surv_words / (double) HeapRegion::GrainWords;
176 } 186 }
177 } 187 }
178 188
179 void 189 void
180 SurvRateGroup::all_surviving_words_recorded(bool propagate) { 190 SurvRateGroup::all_surviving_words_recorded(bool propagate) {
181 if (propagate && _curr_length > 0) { // conservative 191 if (propagate && _region_num > 0) { // conservative
182 double surv_rate = _surv_rate_pred[_curr_length-1]->last(); 192 double surv_rate = _surv_rate_pred[_region_num-1]->last();
183 193
184 #if 0 194 #if 0
185 gclog_or_tty->print_cr("propagating %1.2lf from %d to %d", 195 gclog_or_tty->print_cr("propagating %1.2lf from %d to %d",
186 surv_rate, _curr_length, _array_length - 1); 196 surv_rate, _curr_length, _array_length - 1);
187 #endif // 0 197 #endif // 0
188 198
189 for (size_t i = _curr_length; i < _array_length; ++i) { 199 for (size_t i = _region_num; i < _stats_arrays_length; ++i) {
190 guarantee( _surv_rate[i] <= 0.00001, 200 guarantee( _surv_rate[i] <= 0.00001,
191 "the slot should not have been updated" ); 201 "the slot should not have been updated" );
192 _surv_rate_pred[i]->add(surv_rate); 202 _surv_rate_pred[i]->add(surv_rate);
193 } 203 }
194 } 204 }
195 205
196 double accum = 0.0; 206 double accum = 0.0;
197 double pred = 0.0; 207 double pred = 0.0;
198 for (size_t i = 0; i < _array_length; ++i) { 208 for (size_t i = 0; i < _stats_arrays_length; ++i) {
199 pred = _g1p->get_new_prediction(_surv_rate_pred[i]); 209 pred = _g1p->get_new_prediction(_surv_rate_pred[i]);
200 if (pred > 1.0) pred = 1.0; 210 if (pred > 1.0) pred = 1.0;
201 accum += pred; 211 accum += pred;
202 _accum_surv_rate_pred[i] = accum; 212 _accum_surv_rate_pred[i] = accum;
203 // gclog_or_tty->print_cr("age %3d, accum %10.2lf", i, accum); 213 // gclog_or_tty->print_cr("age %3d, accum %10.2lf", i, accum);
207 217
208 #ifndef PRODUCT 218 #ifndef PRODUCT
209 void 219 void
210 SurvRateGroup::print() { 220 SurvRateGroup::print() {
211 gclog_or_tty->print_cr("Surv Rate Group: %s (%d entries, %d scan-only)", 221 gclog_or_tty->print_cr("Surv Rate Group: %s (%d entries, %d scan-only)",
212 _name, _curr_length, _scan_only_prefix); 222 _name, _region_num, _scan_only_prefix);
213 for (size_t i = 0; i < _curr_length; ++i) { 223 for (size_t i = 0; i < _region_num; ++i) {
214 gclog_or_tty->print_cr(" age %4d surv rate %6.2lf %% pred %6.2lf %%%s", 224 gclog_or_tty->print_cr(" age %4d surv rate %6.2lf %% pred %6.2lf %%%s",
215 i, _surv_rate[i] * 100.0, 225 i, _surv_rate[i] * 100.0,
216 _g1p->get_new_prediction(_surv_rate_pred[i]) * 100.0, 226 _g1p->get_new_prediction(_surv_rate_pred[i]) * 100.0,
217 (i < _scan_only_prefix) ? " S-O" : " "); 227 (i < _scan_only_prefix) ? " S-O" : " ");
218 } 228 }