1 /*
2 * Copyright (c) 2013, 2017, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
149 _cur_fast_reclaim_humongous_candidates = 0;
150 _cur_fast_reclaim_humongous_reclaimed = 0;
151 _cur_verify_before_time_ms = 0.0;
152 _cur_verify_after_time_ms = 0.0;
153
154 for (int i = 0; i < GCParPhasesSentinel; i++) {
155 if (_gc_par_phases[i] != NULL) {
156 _gc_par_phases[i]->reset();
157 }
158 }
159
160 _ref_phase_times.reset();
161 }
162
163 void G1GCPhaseTimes::note_gc_start() {
164 _gc_start_counter = os::elapsed_counter();
165 reset();
166 }
167
168 #define ASSERT_PHASE_UNINITIALIZED(phase) \
169 assert(_gc_par_phases[phase]->get(i) == uninitialized, "Phase " #phase " reported for thread that was not started");
170
171 double G1GCPhaseTimes::worker_time(GCParPhases phase, uint worker) {
172 double value = _gc_par_phases[phase]->get(worker);
173 if (value != WorkerDataArray<double>::uninitialized()) {
174 return value;
175 }
176 return 0.0;
177 }
178
179 void G1GCPhaseTimes::note_gc_end() {
180 _gc_pause_time_ms = TimeHelper::counter_to_millis(os::elapsed_counter() - _gc_start_counter);
181
182 double uninitialized = WorkerDataArray<double>::uninitialized();
183
184 for (uint i = 0; i < _max_gc_threads; i++) {
185 double worker_start = _gc_par_phases[GCWorkerStart]->get(i);
186 if (worker_start != uninitialized) {
187 assert(_gc_par_phases[GCWorkerEnd]->get(i) != uninitialized, "Worker started but not ended.");
188 double total_worker_time = _gc_par_phases[GCWorkerEnd]->get(i) - _gc_par_phases[GCWorkerStart]->get(i);
189 record_time_secs(GCWorkerTotal, i , total_worker_time);
190
191 double worker_known_time =
192 worker_time(ExtRootScan, i)
193 + worker_time(SATBFiltering, i)
194 + worker_time(UpdateRS, i)
195 + worker_time(ScanRS, i)
196 + worker_time(CodeRoots, i)
197 + worker_time(ObjCopy, i)
198 + worker_time(Termination, i);
199
200 record_time_secs(Other, i, total_worker_time - worker_known_time);
201 } else {
202 // Make sure all slots are uninitialized since this thread did not seem to have been started
203 ASSERT_PHASE_UNINITIALIZED(GCWorkerEnd);
204 ASSERT_PHASE_UNINITIALIZED(ExtRootScan);
205 ASSERT_PHASE_UNINITIALIZED(SATBFiltering);
206 ASSERT_PHASE_UNINITIALIZED(UpdateRS);
207 ASSERT_PHASE_UNINITIALIZED(ScanRS);
208 ASSERT_PHASE_UNINITIALIZED(CodeRoots);
209 ASSERT_PHASE_UNINITIALIZED(ObjCopy);
210 ASSERT_PHASE_UNINITIALIZED(Termination);
211 }
212 }
213 }
214
215 #undef ASSERT_PHASE_UNINITIALIZED
216
217 // record the time a phase took in seconds
218 void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_i, double secs) {
219 _gc_par_phases[phase]->set(worker_i, secs);
220 }
221
222 // add a number of seconds to a phase
223 void G1GCPhaseTimes::add_time_secs(GCParPhases phase, uint worker_i, double secs) {
224 _gc_par_phases[phase]->add(worker_i, secs);
225 }
226
227 void G1GCPhaseTimes::record_thread_work_item(GCParPhases phase, uint worker_i, size_t count, uint index) {
228 _gc_par_phases[phase]->set_thread_work_item(worker_i, count, index);
229 }
230
231 // return the average time for a phase in milliseconds
232 double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
233 return _gc_par_phases[phase]->average() * 1000.0;
234 }
235
236 size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase, uint index) {
237 assert(_gc_par_phases[phase]->thread_work_items(index) != NULL, "No sub count");
238 return _gc_par_phases[phase]->thread_work_items(index)->sum();
239 }
240
241 template <class T>
242 void G1GCPhaseTimes::details(T* phase, const char* indent) const {
243 LogTarget(Trace, gc, phases, task) lt;
244 if (lt.is_enabled()) {
|
1 /*
2 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
149 _cur_fast_reclaim_humongous_candidates = 0;
150 _cur_fast_reclaim_humongous_reclaimed = 0;
151 _cur_verify_before_time_ms = 0.0;
152 _cur_verify_after_time_ms = 0.0;
153
154 for (int i = 0; i < GCParPhasesSentinel; i++) {
155 if (_gc_par_phases[i] != NULL) {
156 _gc_par_phases[i]->reset();
157 }
158 }
159
160 _ref_phase_times.reset();
161 }
162
163 void G1GCPhaseTimes::note_gc_start() {
164 _gc_start_counter = os::elapsed_counter();
165 reset();
166 }
167
168 #define ASSERT_PHASE_UNINITIALIZED(phase) \
169 assert(_gc_par_phases[phase] == NULL || _gc_par_phases[phase]->get(i) == uninitialized, "Phase " #phase " reported for thread that was not started");
170
171 double G1GCPhaseTimes::worker_time(GCParPhases phase, uint worker) {
172 if (_gc_par_phases[phase] == NULL) {
173 return 0.0;
174 }
175 double value = _gc_par_phases[phase]->get(worker);
176 if (value != WorkerDataArray<double>::uninitialized()) {
177 return value;
178 }
179 return 0.0;
180 }
181
182 void G1GCPhaseTimes::note_gc_end() {
183 _gc_pause_time_ms = TimeHelper::counter_to_millis(os::elapsed_counter() - _gc_start_counter);
184
185 double uninitialized = WorkerDataArray<double>::uninitialized();
186
187 for (uint i = 0; i < _max_gc_threads; i++) {
188 double worker_start = _gc_par_phases[GCWorkerStart]->get(i);
189 if (worker_start != uninitialized) {
190 assert(_gc_par_phases[GCWorkerEnd]->get(i) != uninitialized, "Worker started but not ended.");
191 double total_worker_time = _gc_par_phases[GCWorkerEnd]->get(i) - _gc_par_phases[GCWorkerStart]->get(i);
192 record_time_secs(GCWorkerTotal, i , total_worker_time);
193
194 double worker_known_time =
195 worker_time(ExtRootScan, i)
196 + worker_time(SATBFiltering, i)
197 + worker_time(ScanHCC, i)
198 + worker_time(UpdateRS, i)
199 + worker_time(ScanRS, i)
200 + worker_time(CodeRoots, i)
201 + worker_time(ObjCopy, i)
202 + worker_time(Termination, i);
203
204 record_time_secs(Other, i, total_worker_time - worker_known_time);
205 } else {
206 // Make sure all slots are uninitialized since this thread did not seem to have been started
207 ASSERT_PHASE_UNINITIALIZED(GCWorkerEnd);
208 ASSERT_PHASE_UNINITIALIZED(ExtRootScan);
209 ASSERT_PHASE_UNINITIALIZED(SATBFiltering);
210 ASSERT_PHASE_UNINITIALIZED(ScanHCC);
211 ASSERT_PHASE_UNINITIALIZED(UpdateRS);
212 ASSERT_PHASE_UNINITIALIZED(ScanRS);
213 ASSERT_PHASE_UNINITIALIZED(CodeRoots);
214 ASSERT_PHASE_UNINITIALIZED(ObjCopy);
215 ASSERT_PHASE_UNINITIALIZED(Termination);
216 }
217 }
218 }
219
220 #undef ASSERT_PHASE_UNINITIALIZED
221
222 // record the time a phase took in seconds
223 void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_i, double secs) {
224 _gc_par_phases[phase]->set(worker_i, secs);
225 }
226
227 // add a number of seconds to a phase
228 void G1GCPhaseTimes::add_time_secs(GCParPhases phase, uint worker_i, double secs) {
229 _gc_par_phases[phase]->add(worker_i, secs);
230 }
231
232 void G1GCPhaseTimes::move_time_secs(GCParPhases from, GCParPhases to, uint worker_i, double secs) {
233 add_time_secs(from, worker_i, -secs);
234 add_time_secs(to, worker_i, secs);
235 }
236
237 void G1GCPhaseTimes::record_thread_work_item(GCParPhases phase, uint worker_i, size_t count, uint index) {
238 _gc_par_phases[phase]->set_thread_work_item(worker_i, count, index);
239 }
240
241 // return the average time for a phase in milliseconds
242 double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
243 return _gc_par_phases[phase]->average() * 1000.0;
244 }
245
246 size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase, uint index) {
247 assert(_gc_par_phases[phase]->thread_work_items(index) != NULL, "No sub count");
248 return _gc_par_phases[phase]->thread_work_items(index)->sum();
249 }
250
251 template <class T>
252 void G1GCPhaseTimes::details(T* phase, const char* indent) const {
253 LogTarget(Trace, gc, phases, task) lt;
254 if (lt.is_enabled()) {
|