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 }
|
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 }
|