1 /*
   2  * Copyright (c) 2013, 2015, 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  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "gc/g1/concurrentG1Refine.hpp"
  27 #include "gc/g1/g1CollectedHeap.inline.hpp"
  28 #include "gc/g1/g1GCPhaseTimes.hpp"

  29 #include "gc/g1/g1StringDedup.hpp"
  30 #include "gc/g1/workerDataArray.inline.hpp"
  31 #include "memory/allocation.hpp"
  32 #include "logging/log.hpp"
  33 #include "runtime/os.hpp"
  34 
  35 // Helper class for avoiding interleaved logging
  36 class LineBuffer: public StackObj {
  37 
  38 private:
  39   static const int BUFFER_LEN = 1024;
  40   static const int INDENT_CHARS = 3;
  41   char _buffer[BUFFER_LEN];
  42   int _indent_level;
  43   int _cur;
  44 
  45   void vappend(const char* format, va_list ap)  ATTRIBUTE_PRINTF(2, 0) {
  46     int res = vsnprintf(&_buffer[_cur], BUFFER_LEN - _cur, format, ap);
  47     if (res != -1) {
  48       _cur += res;
  49     } else {
  50       DEBUG_ONLY(warning("buffer too small in LineBuffer");)
  51       _buffer[BUFFER_LEN -1] = 0;
  52       _cur = BUFFER_LEN; // vsnprintf above should not add to _buffer if we are called again
  53     }
  54   }
  55 
  56 public:
  57   explicit LineBuffer(int indent_level): _indent_level(indent_level), _cur(0) {
  58     for (; (_cur < BUFFER_LEN && _cur < (_indent_level * INDENT_CHARS)); _cur++) {
  59       _buffer[_cur] = ' ';
  60     }
  61   }
  62 
  63 #ifndef PRODUCT
  64   ~LineBuffer() {
  65     assert(_cur == _indent_level * INDENT_CHARS, "pending data in buffer - append_and_print_cr() not called?");
  66   }
  67 #endif
  68 
  69   void append(const char* format, ...)  ATTRIBUTE_PRINTF(2, 3) {
  70     va_list ap;
  71     va_start(ap, format);
  72     vappend(format, ap);
  73     va_end(ap);
  74   }
  75 
  76   const char* to_string() {

  77     _cur = _indent_level * INDENT_CHARS;
  78     return _buffer;







  79   }
  80 };
  81 
  82 static const char* Indents[4] = {"", "   ", "      ", "         "};
  83 
  84 G1GCPhaseTimes::G1GCPhaseTimes(uint max_gc_threads) :
  85   _max_gc_threads(max_gc_threads)
  86 {
  87   assert(max_gc_threads > 0, "Must have some GC threads");
  88 
  89   _gc_par_phases[GCWorkerStart] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Start:", false, 2);
  90   _gc_par_phases[ExtRootScan] = new WorkerDataArray<double>(max_gc_threads, "Ext Root Scanning:", true, 2);
  91 
  92   // Root scanning phases
  93   _gc_par_phases[ThreadRoots] = new WorkerDataArray<double>(max_gc_threads, "Thread Roots:", true, 3);
  94   _gc_par_phases[StringTableRoots] = new WorkerDataArray<double>(max_gc_threads, "StringTable Roots:", true, 3);
  95   _gc_par_phases[UniverseRoots] = new WorkerDataArray<double>(max_gc_threads, "Universe Roots:", true, 3);
  96   _gc_par_phases[JNIRoots] = new WorkerDataArray<double>(max_gc_threads, "JNI Handles Roots:", true, 3);
  97   _gc_par_phases[ObjectSynchronizerRoots] = new WorkerDataArray<double>(max_gc_threads, "ObjectSynchronizer Roots:", true, 3);
  98   _gc_par_phases[FlatProfilerRoots] = new WorkerDataArray<double>(max_gc_threads, "FlatProfiler Roots:", true, 3);
  99   _gc_par_phases[ManagementRoots] = new WorkerDataArray<double>(max_gc_threads, "Management Roots:", true, 3);
 100   _gc_par_phases[SystemDictionaryRoots] = new WorkerDataArray<double>(max_gc_threads, "SystemDictionary Roots:", true, 3);
 101   _gc_par_phases[CLDGRoots] = new WorkerDataArray<double>(max_gc_threads, "CLDG Roots:", true, 3);
 102   _gc_par_phases[JVMTIRoots] = new WorkerDataArray<double>(max_gc_threads, "JVMTI Roots:", true, 3);
 103   _gc_par_phases[CMRefRoots] = new WorkerDataArray<double>(max_gc_threads, "CM RefProcessor Roots:", true, 3);
 104   _gc_par_phases[WaitForStrongCLD] = new WorkerDataArray<double>(max_gc_threads, "Wait For Strong CLD:", true, 3);
 105   _gc_par_phases[WeakCLDRoots] = new WorkerDataArray<double>(max_gc_threads, "Weak CLD Roots:", true, 3);
 106   _gc_par_phases[SATBFiltering] = new WorkerDataArray<double>(max_gc_threads, "SATB Filtering:", true, 3);
 107 
 108   _gc_par_phases[UpdateRS] = new WorkerDataArray<double>(max_gc_threads, "Update RS:", true, 2);
 109   _gc_par_phases[ScanHCC] = new WorkerDataArray<double>(max_gc_threads, "Scan HCC:", true, 3);
 110   _gc_par_phases[ScanHCC]->set_enabled(ConcurrentG1Refine::hot_card_cache_enabled());
 111   _gc_par_phases[ScanRS] = new WorkerDataArray<double>(max_gc_threads, "Scan RS:", true, 2);
 112   _gc_par_phases[CodeRoots] = new WorkerDataArray<double>(max_gc_threads, "Code Root Scanning:", true, 2);
 113   _gc_par_phases[ObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Object Copy:", true, 2);
 114   _gc_par_phases[Termination] = new WorkerDataArray<double>(max_gc_threads, "Termination:", true, 2);
 115   _gc_par_phases[GCWorkerTotal] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Total:", true, 2);
 116   _gc_par_phases[GCWorkerEnd] = new WorkerDataArray<double>(max_gc_threads, "GC Worker End:", false, 2);
 117   _gc_par_phases[Other] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Other:", true, 2);
 118 
 119   _update_rs_processed_buffers = new WorkerDataArray<size_t>(max_gc_threads, "Processed Buffers:", true, 3);
 120   _gc_par_phases[UpdateRS]->link_thread_work_items(_update_rs_processed_buffers);
 121 
 122   _termination_attempts = new WorkerDataArray<size_t>(max_gc_threads, "Termination Attempts:", true, 3);
 123   _gc_par_phases[Termination]->link_thread_work_items(_termination_attempts);
 124 
 125   _gc_par_phases[StringDedupQueueFixup] = new WorkerDataArray<double>(max_gc_threads, "Queue Fixup:", true, 2);
 126   _gc_par_phases[StringDedupTableFixup] = new WorkerDataArray<double>(max_gc_threads, "Table Fixup:", true, 2);
 127 
 128   _gc_par_phases[RedirtyCards] = new WorkerDataArray<double>(max_gc_threads, "Parallel Redirty", true, 3);
 129   _redirtied_cards = new WorkerDataArray<size_t>(max_gc_threads, "Redirtied Cards:", true, 3);
 130   _gc_par_phases[RedirtyCards]->link_thread_work_items(_redirtied_cards);
 131 }
 132 
 133 void G1GCPhaseTimes::note_gc_start(uint active_gc_threads) {
 134   assert(active_gc_threads > 0, "The number of threads must be > 0");
 135   assert(active_gc_threads <= _max_gc_threads, "The number of active threads must be <= the max number of threads");
 136   _active_gc_threads = active_gc_threads;
 137   _cur_expand_heap_time_ms = 0.0;
 138 
 139   for (int i = 0; i < GCParPhasesSentinel; i++) {
 140     _gc_par_phases[i]->reset();
 141   }
 142 
 143   _gc_par_phases[StringDedupQueueFixup]->set_enabled(G1StringDedup::is_enabled());
 144   _gc_par_phases[StringDedupTableFixup]->set_enabled(G1StringDedup::is_enabled());
 145 }
 146 
 147 void G1GCPhaseTimes::note_gc_end() {
 148   for (uint i = 0; i < _active_gc_threads; i++) {
 149     double worker_time = _gc_par_phases[GCWorkerEnd]->get(i) - _gc_par_phases[GCWorkerStart]->get(i);
 150     record_time_secs(GCWorkerTotal, i , worker_time);
 151 
 152     double worker_known_time =
 153         _gc_par_phases[ExtRootScan]->get(i) +
 154         _gc_par_phases[SATBFiltering]->get(i) +
 155         _gc_par_phases[UpdateRS]->get(i) +
 156         _gc_par_phases[ScanRS]->get(i) +
 157         _gc_par_phases[CodeRoots]->get(i) +
 158         _gc_par_phases[ObjCopy]->get(i) +
 159         _gc_par_phases[Termination]->get(i);
 160 
 161     record_time_secs(Other, i, worker_time - worker_known_time);
 162   }
 163 
 164   for (int i = 0; i < GCParPhasesSentinel; i++) {
 165     _gc_par_phases[i]->verify(_active_gc_threads);
 166   }
 167 }
 168 
 169 void G1GCPhaseTimes::print_stats(const char* indent, const char* str, double value) {
 170   log_debug(gc, phases)("%s%s: %.1lf ms", indent, str, value);








 171 }
 172 
 173 double G1GCPhaseTimes::accounted_time_ms() {
 174     // Subtract the root region scanning wait time. It's initialized to
 175     // zero at the start of the pause.
 176     double misc_time_ms = _root_region_scan_wait_time_ms;
 177 
 178     misc_time_ms += _cur_collection_par_time_ms;
 179 
 180     // Now subtract the time taken to fix up roots in generated code
 181     misc_time_ms += _cur_collection_code_root_fixup_time_ms;
 182 
 183     // Strong code root purge time
 184     misc_time_ms += _cur_strong_code_root_purge_time_ms;
 185 
 186     if (G1StringDedup::is_enabled()) {
 187       // String dedup fixup time
 188       misc_time_ms += _cur_string_dedup_fixup_time_ms;
 189     }
 190 
 191     // Subtract the time taken to clean the card table from the
 192     // current value of "other time"
 193     misc_time_ms += _cur_clear_ct_time_ms;
 194 
 195     // Remove expand heap time from "other time"
 196     misc_time_ms += _cur_expand_heap_time_ms;
 197 
 198     return misc_time_ms;
 199 }
 200 
 201 // record the time a phase took in seconds
 202 void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_i, double secs) {
 203   _gc_par_phases[phase]->set(worker_i, secs);
 204 }
 205 
 206 // add a number of seconds to a phase
 207 void G1GCPhaseTimes::add_time_secs(GCParPhases phase, uint worker_i, double secs) {
 208   _gc_par_phases[phase]->add(worker_i, secs);
 209 }
 210 
 211 void G1GCPhaseTimes::record_thread_work_item(GCParPhases phase, uint worker_i, size_t count) {
 212   _gc_par_phases[phase]->set_thread_work_item(worker_i, count);
 213 }
 214 
 215 // return the average time for a phase in milliseconds
 216 double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
 217   return _gc_par_phases[phase]->average(_active_gc_threads) * 1000.0;
 218 }
 219 
 220 double G1GCPhaseTimes::get_time_ms(GCParPhases phase, uint worker_i) {
 221   return _gc_par_phases[phase]->get(worker_i) * 1000.0;
 222 }
 223 
 224 double G1GCPhaseTimes::sum_time_ms(GCParPhases phase) {
 225   return _gc_par_phases[phase]->sum(_active_gc_threads) * 1000.0;
 226 }
 227 
 228 double G1GCPhaseTimes::min_time_ms(GCParPhases phase) {
 229   return _gc_par_phases[phase]->minimum(_active_gc_threads) * 1000.0;
 230 }
 231 
 232 double G1GCPhaseTimes::max_time_ms(GCParPhases phase) {
 233   return _gc_par_phases[phase]->maximum(_active_gc_threads) * 1000.0;
 234 }
 235 
 236 size_t G1GCPhaseTimes::get_thread_work_item(GCParPhases phase, uint worker_i) {
 237   assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
 238   return _gc_par_phases[phase]->thread_work_items()->get(worker_i);
 239 }
 240 
 241 size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase) {
 242   assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
 243   return _gc_par_phases[phase]->thread_work_items()->sum(_active_gc_threads);
 244 }
 245 
 246 double G1GCPhaseTimes::average_thread_work_items(GCParPhases phase) {
 247   assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
 248   return _gc_par_phases[phase]->thread_work_items()->average(_active_gc_threads);
 249 }
 250 
 251 size_t G1GCPhaseTimes::min_thread_work_items(GCParPhases phase) {
 252   assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
 253   return _gc_par_phases[phase]->thread_work_items()->minimum(_active_gc_threads);
 254 }
 255 
 256 size_t G1GCPhaseTimes::max_thread_work_items(GCParPhases phase) {
 257   assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
 258   return _gc_par_phases[phase]->thread_work_items()->maximum(_active_gc_threads);
 259 }
 260 
 261 class G1GCParPhasePrinter : public StackObj {
 262   G1GCPhaseTimes* _phase_times;
 263  public:
 264   G1GCParPhasePrinter(G1GCPhaseTimes* phase_times) : _phase_times(phase_times) {}
 265 
 266   void print(G1GCPhaseTimes::GCParPhases phase_id) {
 267     WorkerDataArray<double>* phase = _phase_times->_gc_par_phases[phase_id];
 268 




 269     if (phase->_length == 1) {
 270       print_single_length(phase_id, phase);
 271     } else {
 272       print_multi_length(phase_id, phase);
 273     }
 274   }
 275 

 276 
 277  private:
 278   void print_single_length(G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<double>* phase) {
 279     // No need for min, max, average and sum for only one worker
 280     log_debug(gc, phases)("%s%s:  %.1lf", Indents[phase->_indent_level], phase->_title, _phase_times->get_time_ms(phase_id, 0));

 281 
 282     WorkerDataArray<size_t>* work_items = phase->_thread_work_items;
 283     if (work_items != NULL) {
 284       log_debug(gc, phases)("%s%s:  " SIZE_FORMAT, Indents[work_items->_indent_level], work_items->_title, _phase_times->sum_thread_work_items(phase_id));
 285     }
 286   }
 287 
 288   void print_time_values(const char* indent, G1GCPhaseTimes::GCParPhases phase_id) {
 289     if (Log<LogTag::gc>::is_level(LogLevel::Trace)) {
 290       LineBuffer buf(0);
 291       uint active_length = _phase_times->_active_gc_threads;
 292       for (uint i = 0; i < active_length; ++i) {
 293         buf.append(" %4.1lf", _phase_times->get_time_ms(phase_id, i));
 294       }
 295       const char* line = buf.to_string();
 296       log_trace(gc, phases)("%s%-25s%s", indent, "", line);
 297     }

 298   }
 299 
 300   void print_count_values(const char* indent, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<size_t>* thread_work_items) {
 301     if (Log<LogTag::gc>::is_level(LogLevel::Trace)) {
 302       LineBuffer buf(0);
 303       uint active_length = _phase_times->_active_gc_threads;
 304       for (uint i = 0; i < active_length; ++i) {
 305         buf.append("  " SIZE_FORMAT, _phase_times->get_thread_work_item(phase_id, i));
 306       }
 307       const char* line = buf.to_string();
 308       log_trace(gc, phases)("%s%-25s%s", indent, "", line);
 309     }
 310   }
 311 
 312   void print_thread_work_items(G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<size_t>* thread_work_items) {
 313     const char* indent = Indents[thread_work_items->_indent_level];





 314 
 315     assert(thread_work_items->_print_sum, "%s does not have print sum true even though it is a count", thread_work_items->_title);
 316 
 317     log_debug(gc, phases)("%s%-25s Min: " SIZE_FORMAT ", Avg: %4.1lf, Max: " SIZE_FORMAT ", Diff: " SIZE_FORMAT ", Sum: " SIZE_FORMAT,
 318         indent, thread_work_items->_title,
 319         _phase_times->min_thread_work_items(phase_id), _phase_times->average_thread_work_items(phase_id), _phase_times->max_thread_work_items(phase_id),
 320         _phase_times->max_thread_work_items(phase_id) - _phase_times->min_thread_work_items(phase_id), _phase_times->sum_thread_work_items(phase_id));
 321 
 322     print_count_values(indent, phase_id, thread_work_items);
 323   }
 324 
 325   void print_multi_length(G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<double>* phase) {
 326     const char* indent = Indents[phase->_indent_level];

 327 
 328     if (phase->_print_sum) {
 329       log_debug(gc, phases)("%s%-25s Min: %4.1lf, Avg: %4.1lf, Max: %4.1lf, Diff: %4.1lf, Sum: %4.1lf",
 330           indent, phase->_title,
 331           _phase_times->min_time_ms(phase_id), _phase_times->average_time_ms(phase_id), _phase_times->max_time_ms(phase_id),
 332           _phase_times->max_time_ms(phase_id) - _phase_times->min_time_ms(phase_id), _phase_times->sum_time_ms(phase_id));
 333     } else {
 334       log_debug(gc, phases)("%s%-25s Min: %4.1lf, Avg: %4.1lf, Max: %4.1lf, Diff: %4.1lf",
 335           indent, phase->_title,
 336           _phase_times->min_time_ms(phase_id), _phase_times->average_time_ms(phase_id), _phase_times->max_time_ms(phase_id),
 337           _phase_times->max_time_ms(phase_id) - _phase_times->min_time_ms(phase_id));





 338     }
 339 
 340     print_time_values(indent, phase_id);
 341 
 342     if (phase->_thread_work_items != NULL) {
 343       print_thread_work_items(phase_id, phase->_thread_work_items);
 344     }
 345   }
 346 };
 347 
 348 void G1GCPhaseTimes::print(double pause_time_sec) {
 349   note_gc_end();
 350 
 351   G1GCParPhasePrinter par_phase_printer(this);
 352 
 353   if (_root_region_scan_wait_time_ms > 0.0) {
 354     print_stats(Indents[1], "Root Region Scan Waiting", _root_region_scan_wait_time_ms);
 355   }
 356 
 357   print_stats(Indents[1], "Parallel Time", _cur_collection_par_time_ms); //, _active_gc_threads);
 358   for (int i = 0; i <= GCMainParPhasesLast; i++) {
 359     par_phase_printer.print((GCParPhases) i);
 360   }
 361 
 362   print_stats(Indents[1], "Code Root Fixup", _cur_collection_code_root_fixup_time_ms);
 363   print_stats(Indents[1], "Code Root Purge", _cur_strong_code_root_purge_time_ms);
 364   if (G1StringDedup::is_enabled()) {
 365     print_stats(Indents[1], "String Dedup Fixup", _cur_string_dedup_fixup_time_ms); //, _active_gc_threads);
 366     for (int i = StringDedupPhasesFirst; i <= StringDedupPhasesLast; i++) {
 367       par_phase_printer.print((GCParPhases) i);
 368     }
 369   }
 370   print_stats(Indents[1], "Clear CT", _cur_clear_ct_time_ms);
 371   print_stats(Indents[1], "Expand Heap After Collection", _cur_expand_heap_time_ms);

 372   double misc_time_ms = pause_time_sec * MILLIUNITS - accounted_time_ms();
 373   print_stats(Indents[1], "Other", misc_time_ms);
 374   if (_cur_verify_before_time_ms > 0.0) {
 375     print_stats(Indents[2], "Verify Before", _cur_verify_before_time_ms);
 376   }
 377   if (G1CollectedHeap::heap()->evacuation_failed()) {
 378     double evac_fail_handling = _cur_evac_fail_recalc_used + _cur_evac_fail_remove_self_forwards +
 379       _cur_evac_fail_restore_remsets;
 380     print_stats(Indents[2], "Evacuation Failure", evac_fail_handling);
 381     log_trace(gc, phases)("%sRecalculate Used: %.1lf ms", Indents[3], _cur_evac_fail_recalc_used);
 382     log_trace(gc, phases)("%sRemove Self Forwards: %.1lf ms", Indents[3], _cur_evac_fail_remove_self_forwards);
 383     log_trace(gc, phases)("%sRestore RemSet: %.1lf ms", Indents[3], _cur_evac_fail_restore_remsets);


 384   }
 385   print_stats(Indents[2], "Choose CSet",
 386     (_recorded_young_cset_choice_time_ms +
 387     _recorded_non_young_cset_choice_time_ms));
 388   print_stats(Indents[2], "Ref Proc", _cur_ref_proc_time_ms);
 389   print_stats(Indents[2], "Ref Enq", _cur_ref_enq_time_ms);
 390   print_stats(Indents[2], "Redirty Cards", _recorded_redirty_logged_cards_time_ms);
 391   par_phase_printer.print(RedirtyCards);
 392   if (G1EagerReclaimHumongousObjects) {
 393     print_stats(Indents[2], "Humongous Register", _cur_fast_reclaim_humongous_register_time_ms);
 394 
 395     log_trace(gc, phases)("%sHumongous Total: %.1lf ms", Indents[3], _cur_evac_fail_recalc_used);
 396     log_trace(gc, phases)("%sHumongous Candidate: " SIZE_FORMAT, Indents[3], _cur_fast_reclaim_humongous_candidates);
 397     print_stats(Indents[2], "Humongous Reclaim", _cur_fast_reclaim_humongous_time_ms);
 398     log_trace(gc, phases)("%sHumongous Reclaimed: " SIZE_FORMAT, Indents[3], _cur_fast_reclaim_humongous_reclaimed);



 399   }
 400   print_stats(Indents[2], "Free CSet",
 401     (_recorded_young_free_cset_time_ms +
 402     _recorded_non_young_free_cset_time_ms));
 403   log_trace(gc, phases)("%sYoung Free CSet: %.1lf ms", Indents[3], _recorded_young_free_cset_time_ms);
 404   log_trace(gc, phases)("%sNon-Young Free CSet: %.1lf ms", Indents[3], _recorded_non_young_free_cset_time_ms);


 405   if (_cur_verify_after_time_ms > 0.0) {
 406     print_stats(Indents[2], "Verify After", _cur_verify_after_time_ms);
 407   }
 408 }
 409 
 410 G1GCParPhaseTimesTracker::G1GCParPhaseTimesTracker(G1GCPhaseTimes* phase_times, G1GCPhaseTimes::GCParPhases phase, uint worker_id) :
 411     _phase_times(phase_times), _phase(phase), _worker_id(worker_id) {
 412   if (_phase_times != NULL) {
 413     _start_time = os::elapsedTime();
 414   }
 415 }
 416 
 417 G1GCParPhaseTimesTracker::~G1GCParPhaseTimesTracker() {
 418   if (_phase_times != NULL) {
 419     _phase_times->record_time_secs(_phase, _worker_id, os::elapsedTime() - _start_time);
 420   }
 421 }
 422 
--- EOF ---