< prev index next >

src/hotspot/share/gc/g1/g1GCPhaseTimes.cpp

Print this page
rev 59958 : [mq]: 8247819-kbarrett-review


  36 #include "logging/logStream.hpp"
  37 #include "runtime/timer.hpp"
  38 #include "runtime/os.hpp"
  39 #include "utilities/macros.hpp"
  40 
  41 static const char* indent(uint level) {
  42   static const char* Indents[] = {"", "  ", "    ", "      ", "        ", "          "};
  43   assert(level < ARRAY_SIZE(Indents), "Too high indent level %u", level);
  44   return Indents[level];
  45 }
  46 
  47 G1GCPhaseTimes::G1GCPhaseTimes(STWGCTimer* gc_timer, uint max_gc_threads) :
  48   _max_gc_threads(max_gc_threads),
  49   _gc_start_counter(0),
  50   _gc_pause_time_ms(0.0),
  51   _ref_phase_times(gc_timer, max_gc_threads),
  52   _weak_phase_times(max_gc_threads)
  53 {
  54   assert(max_gc_threads > 0, "Must have some GC threads");
  55 
  56   _gc_par_phases[GCWorkerStart] = new WorkerDataArray<double>("GC Worker Start (ms):", max_gc_threads);
  57   _gc_par_phases[ExtRootScan] = new WorkerDataArray<double>("Ext Root Scanning (ms):", max_gc_threads);
  58 
  59   // Root scanning phases
  60   _gc_par_phases[ThreadRoots] = new WorkerDataArray<double>("Thread Roots (ms):", max_gc_threads);
  61   _gc_par_phases[UniverseRoots] = new WorkerDataArray<double>("Universe Roots (ms):", max_gc_threads);
  62   _gc_par_phases[JNIRoots] = new WorkerDataArray<double>("JNI Handles Roots (ms):", max_gc_threads);
  63   _gc_par_phases[ObjectSynchronizerRoots] = new WorkerDataArray<double>("ObjectSynchronizer Roots (ms):", max_gc_threads);
  64   _gc_par_phases[ManagementRoots] = new WorkerDataArray<double>("Management Roots (ms):", max_gc_threads);
  65   _gc_par_phases[VMGlobalRoots] = new WorkerDataArray<double>("VM Global Roots (ms):", max_gc_threads);
  66   _gc_par_phases[CLDGRoots] = new WorkerDataArray<double>("CLDG Roots (ms):", max_gc_threads);
  67   _gc_par_phases[JVMTIRoots] = new WorkerDataArray<double>("JVMTI Roots (ms):", max_gc_threads);
  68   AOT_ONLY(_gc_par_phases[AOTCodeRoots] = new WorkerDataArray<double>("AOT Root Scan (ms):", max_gc_threads);)
  69   _gc_par_phases[CMRefRoots] = new WorkerDataArray<double>("CM RefProcessor Roots (ms):", max_gc_threads);







  70 
  71   _gc_par_phases[MergeER] = new WorkerDataArray<double>("Eager Reclaim (ms):", max_gc_threads);
  72 
  73   _gc_par_phases[MergeRS] = new WorkerDataArray<double>("Remembered Sets (ms):", max_gc_threads);
  74   _gc_par_phases[MergeRS]->create_thread_work_items("Merged Sparse:", MergeRSMergedSparse);
  75   _gc_par_phases[MergeRS]->create_thread_work_items("Merged Fine:", MergeRSMergedFine);
  76   _gc_par_phases[MergeRS]->create_thread_work_items("Merged Coarse:", MergeRSMergedCoarse);
  77   _gc_par_phases[MergeRS]->create_thread_work_items("Dirty Cards:", MergeRSDirtyCards);
  78 
  79   _gc_par_phases[OptMergeRS] = new WorkerDataArray<double>("Optional Remembered Sets (ms):", max_gc_threads);
  80   _gc_par_phases[OptMergeRS]->create_thread_work_items("Merged Sparse:", MergeRSMergedSparse);
  81   _gc_par_phases[OptMergeRS]->create_thread_work_items("Merged Fine:", MergeRSMergedFine);
  82   _gc_par_phases[OptMergeRS]->create_thread_work_items("Merged Coarse:", MergeRSMergedCoarse);
  83   _gc_par_phases[OptMergeRS]->create_thread_work_items("Dirty Cards:", MergeRSDirtyCards);
  84 
  85   _gc_par_phases[MergeLB] = new WorkerDataArray<double>("Log Buffers (ms):", max_gc_threads);
  86   if (G1HotCardCache::default_use_cache()) {
  87     _gc_par_phases[MergeHCC] = new WorkerDataArray<double>("Hot Card Cache (ms):", max_gc_threads);
  88     _gc_par_phases[MergeHCC]->create_thread_work_items("Dirty Cards:", MergeHCCDirtyCards);
  89     _gc_par_phases[MergeHCC]->create_thread_work_items("Skipped Cards:", MergeHCCSkippedCards);
  90   } else {
  91     _gc_par_phases[MergeHCC] = NULL;
  92   }
  93   _gc_par_phases[ScanHR] = new WorkerDataArray<double>("Scan Heap Roots (ms):", max_gc_threads);
  94   _gc_par_phases[OptScanHR] = new WorkerDataArray<double>("Optional Scan Heap Roots (ms):", max_gc_threads);
  95   _gc_par_phases[CodeRoots] = new WorkerDataArray<double>("Code Root Scan (ms):", max_gc_threads);
  96   _gc_par_phases[OptCodeRoots] = new WorkerDataArray<double>("Optional Code Root Scan (ms):", max_gc_threads);
  97   _gc_par_phases[ObjCopy] = new WorkerDataArray<double>("Object Copy (ms):", max_gc_threads);
  98   _gc_par_phases[OptObjCopy] = new WorkerDataArray<double>("Optional Object Copy (ms):", max_gc_threads);
  99   _gc_par_phases[Termination] = new WorkerDataArray<double>("Termination (ms):", max_gc_threads);
 100   _gc_par_phases[OptTermination] = new WorkerDataArray<double>("Optional Termination (ms):", max_gc_threads);
 101   _gc_par_phases[GCWorkerTotal] = new WorkerDataArray<double>("GC Worker Total (ms):", max_gc_threads);
 102   _gc_par_phases[GCWorkerEnd] = new WorkerDataArray<double>("GC Worker End (ms):", max_gc_threads);
 103   _gc_par_phases[Other] = new WorkerDataArray<double>("GC Worker Other (ms):", max_gc_threads);
 104 
 105   _gc_par_phases[ScanHR]->create_thread_work_items("Scanned Cards:", ScanHRScannedCards);
 106   _gc_par_phases[ScanHR]->create_thread_work_items("Scanned Blocks:", ScanHRScannedBlocks);
 107   _gc_par_phases[ScanHR]->create_thread_work_items("Claimed Chunks:", ScanHRClaimedChunks);
 108 
 109   _gc_par_phases[OptScanHR]->create_thread_work_items("Scanned Cards:", ScanHRScannedCards);
 110   _gc_par_phases[OptScanHR]->create_thread_work_items("Scanned Blocks:", ScanHRScannedBlocks);
 111   _gc_par_phases[OptScanHR]->create_thread_work_items("Claimed Chunks:", ScanHRClaimedChunks);
 112   _gc_par_phases[OptScanHR]->create_thread_work_items("Scanned Refs:", ScanHRScannedOptRefs);
 113   _gc_par_phases[OptScanHR]->create_thread_work_items("Used Memory:", ScanHRUsedMemory);
 114 
 115   _gc_par_phases[MergeLB]->create_thread_work_items("Dirty Cards:", MergeLBDirtyCards);
 116   _gc_par_phases[MergeLB]->create_thread_work_items("Skipped Cards:", MergeLBSkippedCards);
 117 
 118   _gc_par_phases[MergePSS] = new WorkerDataArray<double>("Merge Per-Thread State", 1 /* length */, true /* is_serial */);
 119 
 120   _gc_par_phases[MergePSS]->create_thread_work_items("Copied Bytes", MergePSSCopiedBytes, max_gc_threads);
 121   _gc_par_phases[MergePSS]->create_thread_work_items("LAB Waste", MergePSSLABWasteBytes, max_gc_threads);
 122   _gc_par_phases[MergePSS]->create_thread_work_items("LAB Undo Waste", MergePSSLABUndoWasteBytes, max_gc_threads);
 123 
 124   _gc_par_phases[Termination]->create_thread_work_items("Termination Attempts:");
 125 
 126   _gc_par_phases[OptTermination]->create_thread_work_items("Optional Termination Attempts:");
 127 
 128   if (UseStringDeduplication) {
 129     _gc_par_phases[StringDedupQueueFixup] = new WorkerDataArray<double>("Queue Fixup (ms):", max_gc_threads);
 130     _gc_par_phases[StringDedupTableFixup] = new WorkerDataArray<double>("Table Fixup (ms):", max_gc_threads);
 131   } else {
 132     _gc_par_phases[StringDedupQueueFixup] = NULL;
 133     _gc_par_phases[StringDedupTableFixup] = NULL;
 134   }
 135 
 136   _gc_par_phases[RedirtyCards] = new WorkerDataArray<double>("Parallel Redirty (ms):", max_gc_threads);
 137   _gc_par_phases[RedirtyCards]->create_thread_work_items("Redirtied Cards:");
 138 
 139   _gc_par_phases[ParFreeCSet] = new WorkerDataArray<double>("Parallel Free Collection Set (ms):", max_gc_threads);
 140   _gc_par_phases[YoungFreeCSet] = new WorkerDataArray<double>("Young Free Collection Set (ms):", max_gc_threads);
 141   _gc_par_phases[NonYoungFreeCSet] = new WorkerDataArray<double>("Non-Young Free Collection Set (ms):", max_gc_threads);
 142   _gc_par_phases[RebuildFreeList] = new WorkerDataArray<double>("Parallel Rebuild Free List (ms):", max_gc_threads);
 143 
 144   reset();
 145 }
 146 
 147 void G1GCPhaseTimes::reset() {
 148   _cur_collection_initial_evac_time_ms = 0.0;
 149   _cur_optional_evac_time_ms = 0.0;
 150   _cur_collection_code_root_fixup_time_ms = 0.0;
 151   _cur_strong_code_root_purge_time_ms = 0.0;
 152   _cur_merge_heap_roots_time_ms = 0.0;
 153   _cur_optional_merge_heap_roots_time_ms = 0.0;
 154   _cur_prepare_merge_heap_roots_time_ms = 0.0;
 155   _cur_optional_prepare_merge_heap_roots_time_ms = 0.0;
 156   _cur_evac_fail_recalc_used = 0.0;
 157   _cur_evac_fail_remove_self_forwards = 0.0;
 158   _cur_string_deduplication_time_ms = 0.0;
 159   _cur_prepare_tlab_time_ms = 0.0;
 160   _cur_resize_tlab_time_ms = 0.0;
 161   _cur_concatenate_dirty_card_logs_time_ms = 0.0;
 162   _cur_derived_pointer_table_update_time_ms = 0.0;


 536 void G1GCPhaseTimes::print() {
 537   note_gc_end();
 538 
 539   if (_cur_verify_before_time_ms > 0.0) {
 540     debug_time("Verify Before", _cur_verify_before_time_ms);
 541   }
 542 
 543   double accounted_ms = 0.0;
 544   accounted_ms += print_pre_evacuate_collection_set();
 545   accounted_ms += print_evacuate_initial_collection_set();
 546   accounted_ms += print_evacuate_optional_collection_set();
 547   accounted_ms += print_post_evacuate_collection_set();
 548   print_other(accounted_ms);
 549 
 550   if (_cur_verify_after_time_ms > 0.0) {
 551     debug_time("Verify After", _cur_verify_after_time_ms);
 552   }
 553 }
 554 
 555 const char* G1GCPhaseTimes::phase_name(GCParPhases phase) {
 556   static const char* names[] = {
 557       "GCWorkerStart",
 558       "ExtRootScan",
 559       "ThreadRoots",
 560       "UniverseRoots",
 561       "JNIRoots",
 562       "ObjectSynchronizerRoots",
 563       "ManagementRoots",
 564       "VMGlobalRoots",
 565       "CLDGRoots",
 566       "JVMTIRoots",
 567       AOT_ONLY("AOTCodeRoots" COMMA)
 568       "CMRefRoots",
 569       "MergeER",
 570       "MergeRS",
 571       "OptMergeRS",
 572       "MergeLB",
 573       "MergeHCC",
 574       "ScanHR",
 575       "OptScanHR",
 576       "CodeRoots",
 577       "OptCodeRoots",
 578       "ObjCopy",
 579       "OptObjCopy",
 580       "Termination",
 581       "OptTermination",
 582       "Other",
 583       "GCWorkerTotal",
 584       "GCWorkerEnd",
 585       "StringDedupQueueFixup",
 586       "StringDedupTableFixup",
 587       "RedirtyCards",
 588       "ParFreeCSet",
 589       "YoungFreeCSet",
 590       "NonYoungFreeCSet",
 591       "RebuildFreeList",
 592       "MergePSS"
 593       //GCParPhasesSentinel only used to tell end of enum
 594       };
 595 
 596   STATIC_ASSERT(ARRAY_SIZE(names) == G1GCPhaseTimes::GCParPhasesSentinel); // GCParPhases enum and corresponding string array should have the same "length", this tries to assert it
 597 
 598   return names[phase];
 599 }
 600 
 601 G1EvacPhaseWithTrimTimeTracker::G1EvacPhaseWithTrimTimeTracker(G1ParScanThreadState* pss, Tickspan& total_time, Tickspan& trim_time) :
 602   _pss(pss),
 603   _start(Ticks::now()),
 604   _total_time(total_time),
 605   _trim_time(trim_time),
 606   _stopped(false) {
 607 
 608   assert(_pss->trim_ticks().value() == 0, "Possibly remaining trim ticks left over from previous use");
 609 }
 610 
 611 G1EvacPhaseWithTrimTimeTracker::~G1EvacPhaseWithTrimTimeTracker() {
 612   if (!_stopped) {
 613     stop();
 614   }
 615 }
 616 
 617 void G1EvacPhaseWithTrimTimeTracker::stop() {
 618   assert(!_stopped, "Should only be called once");




  36 #include "logging/logStream.hpp"
  37 #include "runtime/timer.hpp"
  38 #include "runtime/os.hpp"
  39 #include "utilities/macros.hpp"
  40 
  41 static const char* indent(uint level) {
  42   static const char* Indents[] = {"", "  ", "    ", "      ", "        ", "          "};
  43   assert(level < ARRAY_SIZE(Indents), "Too high indent level %u", level);
  44   return Indents[level];
  45 }
  46 
  47 G1GCPhaseTimes::G1GCPhaseTimes(STWGCTimer* gc_timer, uint max_gc_threads) :
  48   _max_gc_threads(max_gc_threads),
  49   _gc_start_counter(0),
  50   _gc_pause_time_ms(0.0),
  51   _ref_phase_times(gc_timer, max_gc_threads),
  52   _weak_phase_times(max_gc_threads)
  53 {
  54   assert(max_gc_threads > 0, "Must have some GC threads");
  55 
  56   _gc_par_phases[GCWorkerStart] = new WorkerDataArray<double>("GCWorkerStart", "GC Worker Start (ms):", max_gc_threads);
  57   _gc_par_phases[ExtRootScan] = new WorkerDataArray<double>("ExtRootScan", "Ext Root Scanning (ms):", max_gc_threads);
  58 
  59   // Root scanning phases
  60   _gc_par_phases[ThreadRoots] = new WorkerDataArray<double>("ThreadRoots", "Thread Roots (ms):", max_gc_threads);
  61   _gc_par_phases[UniverseRoots] = new WorkerDataArray<double>("UniverseRoots", "Universe Roots (ms):", max_gc_threads);
  62   _gc_par_phases[ObjectSynchronizerRoots] = new WorkerDataArray<double>("ObjectSynchronizerRoots", "ObjectSynchronizer Roots (ms):", max_gc_threads);
  63   _gc_par_phases[ManagementRoots] = new WorkerDataArray<double>("ManagementRoots", "Management Roots (ms):", max_gc_threads);
  64   _gc_par_phases[CLDGRoots] = new WorkerDataArray<double>("CLDGRoots", "CLDG Roots (ms):", max_gc_threads);
  65   _gc_par_phases[JVMTIRoots] = new WorkerDataArray<double>("JVMTIRoots", "JVMTI Roots (ms):", max_gc_threads);
  66   AOT_ONLY(_gc_par_phases[AOTCodeRoots] = new WorkerDataArray<double>("AOTCodeRoots", "AOT Root Scan (ms):", max_gc_threads);)
  67   _gc_par_phases[CMRefRoots] = new WorkerDataArray<double>("CMRefRoots", "CM RefProcessor Roots (ms):", max_gc_threads);
  68 
  69   int index = G1GCPhaseTimes::StrongOopStorageSetRoots;
  70   for (OopStorageSet::Iterator it = OopStorageSet::strong_iterator(); !it.is_end(); ++it, ++index) {
  71     const char* phase_name_postfix = " Roots (ms):";
  72     char* oop_storage_phase_name = NEW_C_HEAP_ARRAY(char, strlen(phase_name_postfix) + strlen(it->name()) + 1, mtGC);
  73     strcpy(oop_storage_phase_name, it->name());
  74     strcat(oop_storage_phase_name, phase_name_postfix);
  75     _gc_par_phases[index] = new WorkerDataArray<double>(it->name(), oop_storage_phase_name, max_gc_threads);
  76   }
  77 
  78   _gc_par_phases[MergeER] = new WorkerDataArray<double>("MergeER", "Eager Reclaim (ms):", max_gc_threads);
  79 
  80   _gc_par_phases[MergeRS] = new WorkerDataArray<double>("MergeRS", "Remembered Sets (ms):", max_gc_threads);
  81   _gc_par_phases[MergeRS]->create_thread_work_items("Merged Sparse:", MergeRSMergedSparse);
  82   _gc_par_phases[MergeRS]->create_thread_work_items("Merged Fine:", MergeRSMergedFine);
  83   _gc_par_phases[MergeRS]->create_thread_work_items("Merged Coarse:", MergeRSMergedCoarse);
  84   _gc_par_phases[MergeRS]->create_thread_work_items("Dirty Cards:", MergeRSDirtyCards);
  85 
  86   _gc_par_phases[OptMergeRS] = new WorkerDataArray<double>("OptMergeRS", "Optional Remembered Sets (ms):", max_gc_threads);
  87   _gc_par_phases[OptMergeRS]->create_thread_work_items("Merged Sparse:", MergeRSMergedSparse);
  88   _gc_par_phases[OptMergeRS]->create_thread_work_items("Merged Fine:", MergeRSMergedFine);
  89   _gc_par_phases[OptMergeRS]->create_thread_work_items("Merged Coarse:", MergeRSMergedCoarse);
  90   _gc_par_phases[OptMergeRS]->create_thread_work_items("Dirty Cards:", MergeRSDirtyCards);
  91 
  92   _gc_par_phases[MergeLB] = new WorkerDataArray<double>("MergeLB", "Log Buffers (ms):", max_gc_threads);
  93   if (G1HotCardCache::default_use_cache()) {
  94     _gc_par_phases[MergeHCC] = new WorkerDataArray<double>("MergeHCC", "Hot Card Cache (ms):", max_gc_threads);
  95     _gc_par_phases[MergeHCC]->create_thread_work_items("Dirty Cards:", MergeHCCDirtyCards);
  96     _gc_par_phases[MergeHCC]->create_thread_work_items("Skipped Cards:", MergeHCCSkippedCards);
  97   } else {
  98     _gc_par_phases[MergeHCC] = NULL;
  99   }
 100   _gc_par_phases[ScanHR] = new WorkerDataArray<double>("ScanHR", "Scan Heap Roots (ms):", max_gc_threads);
 101   _gc_par_phases[OptScanHR] = new WorkerDataArray<double>("OptScanHR", "Optional Scan Heap Roots (ms):", max_gc_threads);
 102   _gc_par_phases[CodeRoots] = new WorkerDataArray<double>("CodeRoots", "Code Root Scan (ms):", max_gc_threads);
 103   _gc_par_phases[OptCodeRoots] = new WorkerDataArray<double>("OptCodeRoots", "Optional Code Root Scan (ms):", max_gc_threads);
 104   _gc_par_phases[ObjCopy] = new WorkerDataArray<double>("ObjCopy", "Object Copy (ms):", max_gc_threads);
 105   _gc_par_phases[OptObjCopy] = new WorkerDataArray<double>("OptObjCopy", "Optional Object Copy (ms):", max_gc_threads);
 106   _gc_par_phases[Termination] = new WorkerDataArray<double>("Termination", "Termination (ms):", max_gc_threads);
 107   _gc_par_phases[OptTermination] = new WorkerDataArray<double>("OptTermination", "Optional Termination (ms):", max_gc_threads);
 108   _gc_par_phases[GCWorkerTotal] = new WorkerDataArray<double>("GCWorkerTotal", "GC Worker Total (ms):", max_gc_threads);
 109   _gc_par_phases[GCWorkerEnd] = new WorkerDataArray<double>("GCWorkerEnd", "GC Worker End (ms):", max_gc_threads);
 110   _gc_par_phases[Other] = new WorkerDataArray<double>("Other", "GC Worker Other (ms):", max_gc_threads);
 111 
 112   _gc_par_phases[ScanHR]->create_thread_work_items("Scanned Cards:", ScanHRScannedCards);
 113   _gc_par_phases[ScanHR]->create_thread_work_items("Scanned Blocks:", ScanHRScannedBlocks);
 114   _gc_par_phases[ScanHR]->create_thread_work_items("Claimed Chunks:", ScanHRClaimedChunks);
 115 
 116   _gc_par_phases[OptScanHR]->create_thread_work_items("Scanned Cards:", ScanHRScannedCards);
 117   _gc_par_phases[OptScanHR]->create_thread_work_items("Scanned Blocks:", ScanHRScannedBlocks);
 118   _gc_par_phases[OptScanHR]->create_thread_work_items("Claimed Chunks:", ScanHRClaimedChunks);
 119   _gc_par_phases[OptScanHR]->create_thread_work_items("Scanned Refs:", ScanHRScannedOptRefs);
 120   _gc_par_phases[OptScanHR]->create_thread_work_items("Used Memory:", ScanHRUsedMemory);
 121 
 122   _gc_par_phases[MergeLB]->create_thread_work_items("Dirty Cards:", MergeLBDirtyCards);
 123   _gc_par_phases[MergeLB]->create_thread_work_items("Skipped Cards:", MergeLBSkippedCards);
 124 
 125   _gc_par_phases[MergePSS] = new WorkerDataArray<double>("MergePSS", "Merge Per-Thread State", 1 /* length */, true /* is_serial */);
 126 
 127   _gc_par_phases[MergePSS]->create_thread_work_items("Copied Bytes", MergePSSCopiedBytes, max_gc_threads);
 128   _gc_par_phases[MergePSS]->create_thread_work_items("LAB Waste", MergePSSLABWasteBytes, max_gc_threads);
 129   _gc_par_phases[MergePSS]->create_thread_work_items("LAB Undo Waste", MergePSSLABUndoWasteBytes, max_gc_threads);
 130 
 131   _gc_par_phases[Termination]->create_thread_work_items("Termination Attempts:");
 132 
 133   _gc_par_phases[OptTermination]->create_thread_work_items("Optional Termination Attempts:");
 134 
 135   if (UseStringDeduplication) {
 136     _gc_par_phases[StringDedupQueueFixup] = new WorkerDataArray<double>("StringDedupQueueFixup", "Queue Fixup (ms):", max_gc_threads);
 137     _gc_par_phases[StringDedupTableFixup] = new WorkerDataArray<double>("StringDedupTableFixup", "Table Fixup (ms):", max_gc_threads);
 138   } else {
 139     _gc_par_phases[StringDedupQueueFixup] = NULL;
 140     _gc_par_phases[StringDedupTableFixup] = NULL;
 141   }
 142 
 143   _gc_par_phases[RedirtyCards] = new WorkerDataArray<double>("RedirtyCards", "Parallel Redirty (ms):", max_gc_threads);
 144   _gc_par_phases[RedirtyCards]->create_thread_work_items("Redirtied Cards:");
 145 
 146   _gc_par_phases[ParFreeCSet] = new WorkerDataArray<double>("ParFreeCSet", "Parallel Free Collection Set (ms):", max_gc_threads);
 147   _gc_par_phases[YoungFreeCSet] = new WorkerDataArray<double>("YoungFreeCSet", "Young Free Collection Set (ms):", max_gc_threads);
 148   _gc_par_phases[NonYoungFreeCSet] = new WorkerDataArray<double>("NonYoungFreeCSet", "Non-Young Free Collection Set (ms):", max_gc_threads);
 149   _gc_par_phases[RebuildFreeList] = new WorkerDataArray<double>("RebuildFreeList", "Parallel Rebuild Free List (ms):", max_gc_threads);
 150 
 151   reset();
 152 }
 153 
 154 void G1GCPhaseTimes::reset() {
 155   _cur_collection_initial_evac_time_ms = 0.0;
 156   _cur_optional_evac_time_ms = 0.0;
 157   _cur_collection_code_root_fixup_time_ms = 0.0;
 158   _cur_strong_code_root_purge_time_ms = 0.0;
 159   _cur_merge_heap_roots_time_ms = 0.0;
 160   _cur_optional_merge_heap_roots_time_ms = 0.0;
 161   _cur_prepare_merge_heap_roots_time_ms = 0.0;
 162   _cur_optional_prepare_merge_heap_roots_time_ms = 0.0;
 163   _cur_evac_fail_recalc_used = 0.0;
 164   _cur_evac_fail_remove_self_forwards = 0.0;
 165   _cur_string_deduplication_time_ms = 0.0;
 166   _cur_prepare_tlab_time_ms = 0.0;
 167   _cur_resize_tlab_time_ms = 0.0;
 168   _cur_concatenate_dirty_card_logs_time_ms = 0.0;
 169   _cur_derived_pointer_table_update_time_ms = 0.0;


 543 void G1GCPhaseTimes::print() {
 544   note_gc_end();
 545 
 546   if (_cur_verify_before_time_ms > 0.0) {
 547     debug_time("Verify Before", _cur_verify_before_time_ms);
 548   }
 549 
 550   double accounted_ms = 0.0;
 551   accounted_ms += print_pre_evacuate_collection_set();
 552   accounted_ms += print_evacuate_initial_collection_set();
 553   accounted_ms += print_evacuate_optional_collection_set();
 554   accounted_ms += print_post_evacuate_collection_set();
 555   print_other(accounted_ms);
 556 
 557   if (_cur_verify_after_time_ms > 0.0) {
 558     debug_time("Verify After", _cur_verify_after_time_ms);
 559   }
 560 }
 561 
 562 const char* G1GCPhaseTimes::phase_name(GCParPhases phase) {
 563   G1GCPhaseTimes* phase_times = G1CollectedHeap::heap()->phase_times();
 564   return phase_times->_gc_par_phases[phase]->short_name();









































 565 }
 566 
 567 G1EvacPhaseWithTrimTimeTracker::G1EvacPhaseWithTrimTimeTracker(G1ParScanThreadState* pss, Tickspan& total_time, Tickspan& trim_time) :
 568   _pss(pss),
 569   _start(Ticks::now()),
 570   _total_time(total_time),
 571   _trim_time(trim_time),
 572   _stopped(false) {
 573 
 574   assert(_pss->trim_ticks().value() == 0, "Possibly remaining trim ticks left over from previous use");
 575 }
 576 
 577 G1EvacPhaseWithTrimTimeTracker::~G1EvacPhaseWithTrimTimeTracker() {
 578   if (!_stopped) {
 579     stop();
 580   }
 581 }
 582 
 583 void G1EvacPhaseWithTrimTimeTracker::stop() {
 584   assert(!_stopped, "Should only be called once");


< prev index next >