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");
|