author | tschatzl |
Fri, 29 Nov 2019 10:20:14 +0100 | |
changeset 59319 | 9ee940f1de90 |
parent 59198 | 92c98aa0f801 |
permissions | -rw-r--r-- |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
1 |
/* |
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
2 |
* Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved. |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
4 |
* |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
5 |
* This code is free software; you can redistribute it and/or modify it |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
7 |
* published by the Free Software Foundation. |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
8 |
* |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
13 |
* accompanied this code). |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
14 |
* |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
15 |
* You should have received a copy of the GNU General Public License version |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
18 |
* |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
21 |
* questions. |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
22 |
* |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
23 |
*/ |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
24 |
|
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
25 |
#include "precompiled.hpp" |
30764 | 26 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
27 |
#include "gc/g1/g1GCPhaseTimes.hpp" |
|
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
37242
diff
changeset
|
28 |
#include "gc/g1/g1HotCardCache.hpp" |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
29 |
#include "gc/g1/g1ParScanThreadState.inline.hpp" |
30764 | 30 |
#include "gc/g1/g1StringDedup.hpp" |
51546
b9f6a4427da9
8072498: Multi-thread JNI weak reference processing
kbarrett
parents:
51332
diff
changeset
|
31 |
#include "gc/shared/gcTimer.hpp" |
46795
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
32 |
#include "gc/shared/workerDataArray.inline.hpp" |
36374 | 33 |
#include "memory/resourceArea.hpp" |
35061 | 34 |
#include "logging/log.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
35 |
#include "logging/logStream.hpp" |
35907
57bdb6243428
8148734: G1: Make G1GCPhaseTimes keep track of the start GC time
brutisso
parents:
35887
diff
changeset
|
36 |
#include "runtime/timer.hpp" |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
37 |
#include "runtime/os.hpp" |
46681
f17cefd211b4
8183935: G1GCPhaseTimes and G1RootProcessor do not include macros.hpp
mgerdin
parents:
46670
diff
changeset
|
38 |
#include "utilities/macros.hpp" |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
39 |
|
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
40 |
static const char* Indents[5] = {"", " ", " ", " ", " "}; |
35061 | 41 |
|
46795
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
42 |
G1GCPhaseTimes::G1GCPhaseTimes(STWGCTimer* gc_timer, uint max_gc_threads) : |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
43 |
_max_gc_threads(max_gc_threads), |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
44 |
_gc_start_counter(0), |
46795
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
45 |
_gc_pause_time_ms(0.0), |
51546
b9f6a4427da9
8072498: Multi-thread JNI weak reference processing
kbarrett
parents:
51332
diff
changeset
|
46 |
_ref_phase_times(gc_timer, max_gc_threads), |
b9f6a4427da9
8072498: Multi-thread JNI weak reference processing
kbarrett
parents:
51332
diff
changeset
|
47 |
_weak_phase_times(max_gc_threads) |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
48 |
{ |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
49 |
assert(max_gc_threads > 0, "Must have some GC threads"); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
50 |
|
36374 | 51 |
_gc_par_phases[GCWorkerStart] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Start (ms):"); |
52 |
_gc_par_phases[ExtRootScan] = new WorkerDataArray<double>(max_gc_threads, "Ext Root Scanning (ms):"); |
|
29694
442c3305ba39
8027962: Per-phase timing measurements for strong roots processing
brutisso
parents:
29680
diff
changeset
|
53 |
|
442c3305ba39
8027962: Per-phase timing measurements for strong roots processing
brutisso
parents:
29680
diff
changeset
|
54 |
// Root scanning phases |
36374 | 55 |
_gc_par_phases[ThreadRoots] = new WorkerDataArray<double>(max_gc_threads, "Thread Roots (ms):"); |
56 |
_gc_par_phases[UniverseRoots] = new WorkerDataArray<double>(max_gc_threads, "Universe Roots (ms):"); |
|
57 |
_gc_par_phases[JNIRoots] = new WorkerDataArray<double>(max_gc_threads, "JNI Handles Roots (ms):"); |
|
58 |
_gc_par_phases[ObjectSynchronizerRoots] = new WorkerDataArray<double>(max_gc_threads, "ObjectSynchronizer Roots (ms):"); |
|
59 |
_gc_par_phases[ManagementRoots] = new WorkerDataArray<double>(max_gc_threads, "Management Roots (ms):"); |
|
60 |
_gc_par_phases[SystemDictionaryRoots] = new WorkerDataArray<double>(max_gc_threads, "SystemDictionary Roots (ms):"); |
|
61 |
_gc_par_phases[CLDGRoots] = new WorkerDataArray<double>(max_gc_threads, "CLDG Roots (ms):"); |
|
62 |
_gc_par_phases[JVMTIRoots] = new WorkerDataArray<double>(max_gc_threads, "JVMTI Roots (ms):"); |
|
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54465
diff
changeset
|
63 |
AOT_ONLY(_gc_par_phases[AOTCodeRoots] = new WorkerDataArray<double>(max_gc_threads, "AOT Root Scan (ms):");) |
36374 | 64 |
_gc_par_phases[CMRefRoots] = new WorkerDataArray<double>(max_gc_threads, "CM RefProcessor Roots (ms):"); |
29694
442c3305ba39
8027962: Per-phase timing measurements for strong roots processing
brutisso
parents:
29680
diff
changeset
|
65 |
|
55723
95706898c3ea
8227089: Add timing information for merging humongous remembered sets
tschatzl
parents:
55722
diff
changeset
|
66 |
_gc_par_phases[MergeER] = new WorkerDataArray<double>(max_gc_threads, "Eager Reclaim (ms):"); |
95706898c3ea
8227089: Add timing information for merging humongous remembered sets
tschatzl
parents:
55722
diff
changeset
|
67 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
68 |
_gc_par_phases[MergeRS] = new WorkerDataArray<double>(max_gc_threads, "Remembered Sets (ms):"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
69 |
_merge_rs_merged_sparse = new WorkerDataArray<size_t>(max_gc_threads, "Merged Sparse:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
70 |
_gc_par_phases[MergeRS]->link_thread_work_items(_merge_rs_merged_sparse, MergeRSMergedSparse); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
71 |
_merge_rs_merged_fine = new WorkerDataArray<size_t>(max_gc_threads, "Merged Fine:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
72 |
_gc_par_phases[MergeRS]->link_thread_work_items(_merge_rs_merged_fine, MergeRSMergedFine); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
73 |
_merge_rs_merged_coarse = new WorkerDataArray<size_t>(max_gc_threads, "Merged Coarse:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
74 |
_gc_par_phases[MergeRS]->link_thread_work_items(_merge_rs_merged_coarse, MergeRSMergedCoarse); |
59319
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
75 |
_merge_rs_dirty_cards = new WorkerDataArray<size_t>(max_gc_threads, "Dirty Cards:"); |
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
76 |
_gc_par_phases[MergeRS]->link_thread_work_items(_merge_rs_dirty_cards, MergeRSDirtyCards); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
77 |
|
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
78 |
_gc_par_phases[OptMergeRS] = new WorkerDataArray<double>(max_gc_threads, "Optional Remembered Sets (ms):"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
79 |
_opt_merge_rs_merged_sparse = new WorkerDataArray<size_t>(max_gc_threads, "Merged Sparse:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
80 |
_gc_par_phases[OptMergeRS]->link_thread_work_items(_opt_merge_rs_merged_sparse, MergeRSMergedSparse); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
81 |
_opt_merge_rs_merged_fine = new WorkerDataArray<size_t>(max_gc_threads, "Merged Fine:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
82 |
_gc_par_phases[OptMergeRS]->link_thread_work_items(_opt_merge_rs_merged_fine, MergeRSMergedFine); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
83 |
_opt_merge_rs_merged_coarse = new WorkerDataArray<size_t>(max_gc_threads, "Merged Coarse:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
84 |
_gc_par_phases[OptMergeRS]->link_thread_work_items(_opt_merge_rs_merged_coarse, MergeRSMergedCoarse); |
59319
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
85 |
_opt_merge_rs_dirty_cards = new WorkerDataArray<size_t>(max_gc_threads, "Dirty Cards:"); |
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
86 |
_gc_par_phases[OptMergeRS]->link_thread_work_items(_opt_merge_rs_dirty_cards, MergeRSDirtyCards); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
87 |
|
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
88 |
_gc_par_phases[MergeLB] = new WorkerDataArray<double>(max_gc_threads, "Log Buffers (ms):"); |
38172
90f405aac699
8155524: HotCardCache shouldn't be part of ConcurrentG1Refine
kbarrett
parents:
37242
diff
changeset
|
89 |
if (G1HotCardCache::default_use_cache()) { |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
90 |
_gc_par_phases[MergeHCC] = new WorkerDataArray<double>(max_gc_threads, "Hot Card Cache (ms):"); |
57508
28ab01c06755
8228388: Add information about dirty/skipped card for Merge HCC in G1 log
tschatzl
parents:
55740
diff
changeset
|
91 |
_merge_hcc_dirty_cards = new WorkerDataArray<size_t>(max_gc_threads, "Dirty Cards:"); |
28ab01c06755
8228388: Add information about dirty/skipped card for Merge HCC in G1 log
tschatzl
parents:
55740
diff
changeset
|
92 |
_gc_par_phases[MergeHCC]->link_thread_work_items(_merge_hcc_dirty_cards, MergeHCCDirtyCards); |
28ab01c06755
8228388: Add information about dirty/skipped card for Merge HCC in G1 log
tschatzl
parents:
55740
diff
changeset
|
93 |
_merge_hcc_skipped_cards = new WorkerDataArray<size_t>(max_gc_threads, "Skipped Cards:"); |
28ab01c06755
8228388: Add information about dirty/skipped card for Merge HCC in G1 log
tschatzl
parents:
55740
diff
changeset
|
94 |
_gc_par_phases[MergeHCC]->link_thread_work_items(_merge_hcc_skipped_cards, MergeHCCSkippedCards); |
36374 | 95 |
} else { |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
96 |
_gc_par_phases[MergeHCC] = NULL; |
57508
28ab01c06755
8228388: Add information about dirty/skipped card for Merge HCC in G1 log
tschatzl
parents:
55740
diff
changeset
|
97 |
_merge_hcc_dirty_cards = NULL; |
28ab01c06755
8228388: Add information about dirty/skipped card for Merge HCC in G1 log
tschatzl
parents:
55740
diff
changeset
|
98 |
_merge_hcc_skipped_cards = NULL; |
36374 | 99 |
} |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
100 |
_gc_par_phases[ScanHR] = new WorkerDataArray<double>(max_gc_threads, "Scan Heap Roots (ms):"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
101 |
_gc_par_phases[OptScanHR] = new WorkerDataArray<double>(max_gc_threads, "Optional Scan Heap Roots (ms):"); |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
102 |
_gc_par_phases[CodeRoots] = new WorkerDataArray<double>(max_gc_threads, "Code Root Scan (ms):"); |
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
103 |
_gc_par_phases[OptCodeRoots] = new WorkerDataArray<double>(max_gc_threads, "Optional Code Root Scan (ms):"); |
36374 | 104 |
_gc_par_phases[ObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Object Copy (ms):"); |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
105 |
_gc_par_phases[OptObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Optional Object Copy (ms):"); |
36374 | 106 |
_gc_par_phases[Termination] = new WorkerDataArray<double>(max_gc_threads, "Termination (ms):"); |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
107 |
_gc_par_phases[OptTermination] = new WorkerDataArray<double>(max_gc_threads, "Optional Termination (ms):"); |
36374 | 108 |
_gc_par_phases[GCWorkerTotal] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Total (ms):"); |
109 |
_gc_par_phases[GCWorkerEnd] = new WorkerDataArray<double>(max_gc_threads, "GC Worker End (ms):"); |
|
110 |
_gc_par_phases[Other] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Other (ms):"); |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
111 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
112 |
_scan_hr_scanned_cards = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Cards:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
113 |
_gc_par_phases[ScanHR]->link_thread_work_items(_scan_hr_scanned_cards, ScanHRScannedCards); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
114 |
_scan_hr_scanned_blocks = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Blocks:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
115 |
_gc_par_phases[ScanHR]->link_thread_work_items(_scan_hr_scanned_blocks, ScanHRScannedBlocks); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
116 |
_scan_hr_claimed_chunks = new WorkerDataArray<size_t>(max_gc_threads, "Claimed Chunks:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
117 |
_gc_par_phases[ScanHR]->link_thread_work_items(_scan_hr_claimed_chunks, ScanHRClaimedChunks); |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
118 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
119 |
_opt_scan_hr_scanned_cards = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Cards:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
120 |
_gc_par_phases[OptScanHR]->link_thread_work_items(_opt_scan_hr_scanned_cards, ScanHRScannedCards); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
121 |
_opt_scan_hr_scanned_blocks = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Blocks:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
122 |
_gc_par_phases[OptScanHR]->link_thread_work_items(_opt_scan_hr_scanned_blocks, ScanHRScannedBlocks); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
123 |
_opt_scan_hr_claimed_chunks = new WorkerDataArray<size_t>(max_gc_threads, "Claimed Chunks:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
124 |
_gc_par_phases[OptScanHR]->link_thread_work_items(_opt_scan_hr_claimed_chunks, ScanHRClaimedChunks); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
125 |
_opt_scan_hr_scanned_opt_refs = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Refs:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
126 |
_gc_par_phases[OptScanHR]->link_thread_work_items(_opt_scan_hr_scanned_opt_refs, ScanHRScannedOptRefs); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
127 |
_opt_scan_hr_used_memory = new WorkerDataArray<size_t>(max_gc_threads, "Used Memory:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
128 |
_gc_par_phases[OptScanHR]->link_thread_work_items(_opt_scan_hr_used_memory, ScanHRUsedMemory); |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
129 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
130 |
_merge_lb_dirty_cards = new WorkerDataArray<size_t>(max_gc_threads, "Dirty Cards:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
131 |
_gc_par_phases[MergeLB]->link_thread_work_items(_merge_lb_dirty_cards, MergeLBDirtyCards); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
132 |
_merge_lb_skipped_cards = new WorkerDataArray<size_t>(max_gc_threads, "Skipped Cards:"); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
133 |
_gc_par_phases[MergeLB]->link_thread_work_items(_merge_lb_skipped_cards, MergeLBSkippedCards); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
134 |
|
59198
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
135 |
_gc_par_phases[MergePSS] = new WorkerDataArray<double>(1, "Merge Per-Thread State", true /* is_serial */); |
53846
fe95464806a7
8219096: Merge print_termination_stats code with current logging
tschatzl
parents:
53819
diff
changeset
|
136 |
|
59198
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
137 |
_merge_pss_copied_bytes = new WorkerDataArray<size_t>(max_gc_threads, "Copied Bytes"); |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
138 |
_gc_par_phases[MergePSS]->link_thread_work_items(_merge_pss_copied_bytes, MergePSSCopiedBytes); |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
139 |
_merge_pss_lab_waste_bytes = new WorkerDataArray<size_t>(max_gc_threads, "LAB Waste"); |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
140 |
_gc_par_phases[MergePSS]->link_thread_work_items(_merge_pss_lab_waste_bytes, MergePSSLABWasteBytes); |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
141 |
_merge_pss_lab_undo_waste_bytes = new WorkerDataArray<size_t>(max_gc_threads, "LAB Undo Waste"); |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
142 |
_gc_par_phases[MergePSS]->link_thread_work_items(_merge_pss_lab_undo_waste_bytes, MergePSSLABUndoWasteBytes); |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
143 |
|
36374 | 144 |
_termination_attempts = new WorkerDataArray<size_t>(max_gc_threads, "Termination Attempts:"); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
145 |
_gc_par_phases[Termination]->link_thread_work_items(_termination_attempts); |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
146 |
|
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
147 |
_opt_termination_attempts = new WorkerDataArray<size_t>(max_gc_threads, "Optional Termination Attempts:"); |
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
148 |
_gc_par_phases[OptTermination]->link_thread_work_items(_opt_termination_attempts); |
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
149 |
|
36374 | 150 |
if (UseStringDeduplication) { |
151 |
_gc_par_phases[StringDedupQueueFixup] = new WorkerDataArray<double>(max_gc_threads, "Queue Fixup (ms):"); |
|
152 |
_gc_par_phases[StringDedupTableFixup] = new WorkerDataArray<double>(max_gc_threads, "Table Fixup (ms):"); |
|
153 |
} else { |
|
154 |
_gc_par_phases[StringDedupQueueFixup] = NULL; |
|
155 |
_gc_par_phases[StringDedupTableFixup] = NULL; |
|
156 |
} |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
157 |
|
36374 | 158 |
_gc_par_phases[RedirtyCards] = new WorkerDataArray<double>(max_gc_threads, "Parallel Redirty (ms):"); |
159 |
_redirtied_cards = new WorkerDataArray<size_t>(max_gc_threads, "Redirtied Cards:"); |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
160 |
_gc_par_phases[RedirtyCards]->link_thread_work_items(_redirtied_cards); |
36367
313c87c050f7
8076463: Add logging for the preserve CM referents task
tschatzl
parents:
35907
diff
changeset
|
161 |
|
39979 | 162 |
_gc_par_phases[YoungFreeCSet] = new WorkerDataArray<double>(max_gc_threads, "Young Free Collection Set (ms):"); |
163 |
_gc_par_phases[NonYoungFreeCSet] = new WorkerDataArray<double>(max_gc_threads, "Non-Young Free Collection Set (ms):"); |
|
164 |
||
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
165 |
reset(); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
166 |
} |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
167 |
|
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
168 |
void G1GCPhaseTimes::reset() { |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
169 |
_cur_collection_initial_evac_time_ms = 0.0; |
58796
7608c17b7463
8232779: G1 current collection parallel time does not include optional evacuation
tschatzl
parents:
58777
diff
changeset
|
170 |
_cur_optional_evac_time_ms = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
171 |
_cur_collection_code_root_fixup_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
172 |
_cur_strong_code_root_purge_time_ms = 0.0; |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
173 |
_cur_merge_heap_roots_time_ms = 0.0; |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
174 |
_cur_optional_merge_heap_roots_time_ms = 0.0; |
55722
5ee183a90e65
8227084: Add timing information for merge heap root preparation
tschatzl
parents:
55510
diff
changeset
|
175 |
_cur_prepare_merge_heap_roots_time_ms = 0.0; |
5ee183a90e65
8227084: Add timing information for merge heap root preparation
tschatzl
parents:
55510
diff
changeset
|
176 |
_cur_optional_prepare_merge_heap_roots_time_ms = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
177 |
_cur_evac_fail_recalc_used = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
178 |
_cur_evac_fail_remove_self_forwards = 0.0; |
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
179 |
_cur_string_deduplication_time_ms = 0.0; |
46330
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
180 |
_cur_prepare_tlab_time_ms = 0.0; |
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
181 |
_cur_resize_tlab_time_ms = 0.0; |
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
182 |
_cur_derived_pointer_table_update_time_ms = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
183 |
_cur_clear_ct_time_ms = 0.0; |
33577 | 184 |
_cur_expand_heap_time_ms = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
185 |
_cur_ref_proc_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
186 |
_cur_collection_start_sec = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
187 |
_root_region_scan_wait_time_ms = 0.0; |
34612
ed475e8089ef
8144145: G1GCPhaseTimes should allow externally accounted time
ehelin
parents:
33739
diff
changeset
|
188 |
_external_accounted_time_ms = 0.0; |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
189 |
_recorded_prepare_heap_roots_time_ms = 0.0; |
42048
c1f066b53dd7
8160055: Misplaced call to ClassLoaderDataGraph::clear_claimed_marks during initial mark
jprovino
parents:
39979
diff
changeset
|
190 |
_recorded_clear_claimed_marks_time_ms = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
191 |
_recorded_young_cset_choice_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
192 |
_recorded_non_young_cset_choice_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
193 |
_recorded_redirty_logged_cards_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
194 |
_recorded_preserve_cm_referents_time_ms = 0.0; |
46330
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
195 |
_recorded_start_new_cset_time_ms = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
196 |
_recorded_total_free_cset_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
197 |
_recorded_serial_free_cset_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
198 |
_cur_fast_reclaim_humongous_time_ms = 0.0; |
54843
25c329958c70
8200545: Improve filter for enqueued deferred cards
tschatzl
parents:
54713
diff
changeset
|
199 |
_cur_region_register_time = 0.0; |
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
200 |
_cur_fast_reclaim_humongous_total = 0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
201 |
_cur_fast_reclaim_humongous_candidates = 0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
202 |
_cur_fast_reclaim_humongous_reclaimed = 0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
203 |
_cur_verify_before_time_ms = 0.0; |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
204 |
_cur_verify_after_time_ms = 0.0; |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
205 |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
206 |
for (int i = 0; i < GCParPhasesSentinel; i++) { |
36374 | 207 |
if (_gc_par_phases[i] != NULL) { |
208 |
_gc_par_phases[i]->reset(); |
|
209 |
} |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
210 |
} |
46795
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
211 |
|
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
212 |
_ref_phase_times.reset(); |
51546
b9f6a4427da9
8072498: Multi-thread JNI weak reference processing
kbarrett
parents:
51332
diff
changeset
|
213 |
_weak_phase_times.reset(); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
214 |
} |
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
215 |
|
42545
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
216 |
void G1GCPhaseTimes::note_gc_start() { |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
217 |
_gc_start_counter = os::elapsed_counter(); |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
218 |
reset(); |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
219 |
} |
af9f4bf4d6d8
8168904: Initialize and reset G1 phase times to zero
ehelin
parents:
42048
diff
changeset
|
220 |
|
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
221 |
#define ASSERT_PHASE_UNINITIALIZED(phase) \ |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
222 |
assert(_gc_par_phases[phase] == NULL || _gc_par_phases[phase]->get(i) == uninitialized, "Phase " #phase " reported for thread that was not started"); |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
223 |
|
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
224 |
double G1GCPhaseTimes::worker_time(GCParPhases phase, uint worker) { |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
225 |
if (_gc_par_phases[phase] == NULL) { |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
226 |
return 0.0; |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
227 |
} |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
228 |
double value = _gc_par_phases[phase]->get(worker); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
229 |
if (value != WorkerDataArray<double>::uninitialized()) { |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
230 |
return value; |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
231 |
} |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
232 |
return 0.0; |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
233 |
} |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
234 |
|
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13288
diff
changeset
|
235 |
void G1GCPhaseTimes::note_gc_end() { |
35907
57bdb6243428
8148734: G1: Make G1GCPhaseTimes keep track of the start GC time
brutisso
parents:
35887
diff
changeset
|
236 |
_gc_pause_time_ms = TimeHelper::counter_to_millis(os::elapsed_counter() - _gc_start_counter); |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
237 |
|
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
238 |
double uninitialized = WorkerDataArray<double>::uninitialized(); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
239 |
|
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
240 |
for (uint i = 0; i < _max_gc_threads; i++) { |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
241 |
double worker_start = _gc_par_phases[GCWorkerStart]->get(i); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
242 |
if (worker_start != uninitialized) { |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
243 |
assert(_gc_par_phases[GCWorkerEnd]->get(i) != uninitialized, "Worker started but not ended."); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
244 |
double total_worker_time = _gc_par_phases[GCWorkerEnd]->get(i) - _gc_par_phases[GCWorkerStart]->get(i); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
245 |
record_time_secs(GCWorkerTotal, i , total_worker_time); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
246 |
|
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
247 |
double worker_known_time = worker_time(ExtRootScan, i) + |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
248 |
worker_time(ScanHR, i) + |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
249 |
worker_time(CodeRoots, i) + |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
250 |
worker_time(ObjCopy, i) + |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
251 |
worker_time(Termination, i); |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
252 |
|
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
253 |
record_time_secs(Other, i, total_worker_time - worker_known_time); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
254 |
} else { |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
255 |
// Make sure all slots are uninitialized since this thread did not seem to have been started |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
256 |
ASSERT_PHASE_UNINITIALIZED(GCWorkerEnd); |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
257 |
ASSERT_PHASE_UNINITIALIZED(ExtRootScan); |
55723
95706898c3ea
8227089: Add timing information for merging humongous remembered sets
tschatzl
parents:
55722
diff
changeset
|
258 |
ASSERT_PHASE_UNINITIALIZED(MergeER); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
259 |
ASSERT_PHASE_UNINITIALIZED(MergeRS); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
260 |
ASSERT_PHASE_UNINITIALIZED(OptMergeRS); |
55723
95706898c3ea
8227089: Add timing information for merging humongous remembered sets
tschatzl
parents:
55722
diff
changeset
|
261 |
ASSERT_PHASE_UNINITIALIZED(MergeHCC); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
262 |
ASSERT_PHASE_UNINITIALIZED(MergeLB); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
263 |
ASSERT_PHASE_UNINITIALIZED(ScanHR); |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
264 |
ASSERT_PHASE_UNINITIALIZED(CodeRoots); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
265 |
ASSERT_PHASE_UNINITIALIZED(OptCodeRoots); |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
266 |
ASSERT_PHASE_UNINITIALIZED(ObjCopy); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
267 |
ASSERT_PHASE_UNINITIALIZED(OptObjCopy); |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
268 |
ASSERT_PHASE_UNINITIALIZED(Termination); |
36374 | 269 |
} |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
270 |
} |
23472 | 271 |
} |
272 |
||
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
273 |
#undef ASSERT_PHASE_UNINITIALIZED |
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
274 |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
275 |
// record the time a phase took in seconds |
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
276 |
void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_id, double secs) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
277 |
_gc_par_phases[phase]->set(worker_id, secs); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
278 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
279 |
|
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
280 |
// add a number of seconds to a phase |
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
281 |
void G1GCPhaseTimes::add_time_secs(GCParPhases phase, uint worker_id, double secs) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
282 |
_gc_par_phases[phase]->add(worker_id, secs); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
283 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
284 |
|
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
285 |
void G1GCPhaseTimes::record_or_add_time_secs(GCParPhases phase, uint worker_id, double secs) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
286 |
if (_gc_par_phases[phase]->get(worker_id) == _gc_par_phases[phase]->uninitialized()) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
287 |
record_time_secs(phase, worker_id, secs); |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
288 |
} else { |
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
289 |
add_time_secs(phase, worker_id, secs); |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
290 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
291 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
292 |
|
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
293 |
double G1GCPhaseTimes::get_time_secs(GCParPhases phase, uint worker_id) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
294 |
return _gc_par_phases[phase]->get(worker_id); |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
295 |
} |
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
296 |
|
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
297 |
void G1GCPhaseTimes::record_thread_work_item(GCParPhases phase, uint worker_id, size_t count, uint index) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
298 |
_gc_par_phases[phase]->set_thread_work_item(worker_id, count, index); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
299 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
300 |
|
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
301 |
void G1GCPhaseTimes::record_or_add_thread_work_item(GCParPhases phase, uint worker_id, size_t count, uint index) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
302 |
_gc_par_phases[phase]->set_or_add_thread_work_item(worker_id, count, index); |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
303 |
} |
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
304 |
|
58264
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
305 |
size_t G1GCPhaseTimes::get_thread_work_item(GCParPhases phase, uint worker_id, uint index) { |
4e96939a5746
8231189: Rename worker_i parameters to worker_id
tschatzl
parents:
58263
diff
changeset
|
306 |
return _gc_par_phases[phase]->get_thread_work_item(worker_id, index); |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
307 |
} |
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
308 |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
309 |
// return the average time for a phase in milliseconds |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
310 |
double G1GCPhaseTimes::average_time_ms(GCParPhases phase) { |
59319
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
311 |
if (_gc_par_phases[phase] == NULL) { |
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
312 |
return 0.0; |
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
313 |
} |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
314 |
return _gc_par_phases[phase]->average() * 1000.0; |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
315 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
316 |
|
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
317 |
size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase, uint index) { |
59319
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
318 |
if (_gc_par_phases[phase] == NULL) { |
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
319 |
return 0; |
9ee940f1de90
8227739: Merge cost predictions for scanning cards and log buffer entries
tschatzl
parents:
59198
diff
changeset
|
320 |
} |
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
321 |
assert(_gc_par_phases[phase]->thread_work_items(index) != NULL, "No sub count"); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
322 |
return _gc_par_phases[phase]->thread_work_items(index)->sum(); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
323 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
324 |
|
36374 | 325 |
template <class T> |
42557 | 326 |
void G1GCPhaseTimes::details(T* phase, const char* indent) const { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
327 |
LogTarget(Trace, gc, phases, task) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
328 |
if (lt.is_enabled()) { |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
329 |
LogStream ls(lt); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
330 |
ls.print("%s", indent); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
331 |
phase->print_details_on(&ls); |
36374 | 332 |
} |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
333 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
334 |
|
42557 | 335 |
void G1GCPhaseTimes::log_phase(WorkerDataArray<double>* phase, uint indent, outputStream* out, bool print_sum) const { |
36374 | 336 |
out->print("%s", Indents[indent]); |
37214
bc4e0e0995e6
8152952: Allow G1 phase logging to use individual number of threads
brutisso
parents:
37209
diff
changeset
|
337 |
phase->print_summary_on(out, print_sum); |
36374 | 338 |
details(phase, Indents[indent]); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
339 |
|
46571
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
340 |
for (uint i = 0; i < phase->MaxThreadWorkItems; i++) { |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
341 |
WorkerDataArray<size_t>* work_items = phase->thread_work_items(i); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
342 |
if (work_items != NULL) { |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
343 |
out->print("%s", Indents[indent + 1]); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
344 |
work_items->print_summary_on(out, true); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
345 |
details(work_items, Indents[indent + 1]); |
c70b36f0730d
8178148: Log more detailed information about scan rs phase
tschatzl
parents:
46353
diff
changeset
|
346 |
} |
36374 | 347 |
} |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
348 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
349 |
|
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
350 |
void G1GCPhaseTimes::debug_phase(WorkerDataArray<double>* phase, uint extra_indent) const { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
351 |
LogTarget(Debug, gc, phases) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
352 |
if (lt.is_enabled()) { |
36374 | 353 |
ResourceMark rm; |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
354 |
LogStream ls(lt); |
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
355 |
log_phase(phase, 2 + extra_indent, &ls, true); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
356 |
} |
36374 | 357 |
} |
35061 | 358 |
|
42557 | 359 |
void G1GCPhaseTimes::trace_phase(WorkerDataArray<double>* phase, bool print_sum) const { |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
360 |
LogTarget(Trace, gc, phases) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
361 |
if (lt.is_enabled()) { |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
362 |
LogStream ls(lt); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46681
diff
changeset
|
363 |
log_phase(phase, 3, &ls, print_sum); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
364 |
} |
36374 | 365 |
} |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
366 |
|
42557 | 367 |
#define TIME_FORMAT "%.1lfms" |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
368 |
|
42557 | 369 |
void G1GCPhaseTimes::info_time(const char* name, double value) const { |
370 |
log_info(gc, phases)("%s%s: " TIME_FORMAT, Indents[1], name, value); |
|
371 |
} |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
372 |
|
42557 | 373 |
void G1GCPhaseTimes::debug_time(const char* name, double value) const { |
374 |
log_debug(gc, phases)("%s%s: " TIME_FORMAT, Indents[2], name, value); |
|
375 |
} |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
376 |
|
46795
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
377 |
void G1GCPhaseTimes::debug_time_for_reference(const char* name, double value) const { |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
378 |
LogTarget(Debug, gc, phases) lt; |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
379 |
LogTarget(Debug, gc, phases, ref) lt2; |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
380 |
|
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
381 |
if (lt.is_enabled()) { |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
382 |
LogStream ls(lt); |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
383 |
ls.print_cr("%s%s: " TIME_FORMAT, Indents[2], name, value); |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
384 |
} else if (lt2.is_enabled()) { |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
385 |
LogStream ls(lt2); |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
386 |
ls.print_cr("%s%s: " TIME_FORMAT, Indents[2], name, value); |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
387 |
} |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
388 |
} |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
389 |
|
42557 | 390 |
void G1GCPhaseTimes::trace_time(const char* name, double value) const { |
391 |
log_trace(gc, phases)("%s%s: " TIME_FORMAT, Indents[3], name, value); |
|
392 |
} |
|
35061 | 393 |
|
42557 | 394 |
void G1GCPhaseTimes::trace_count(const char* name, size_t value) const { |
395 |
log_trace(gc, phases)("%s%s: " SIZE_FORMAT, Indents[3], name, value); |
|
396 |
} |
|
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
397 |
|
42557 | 398 |
double G1GCPhaseTimes::print_pre_evacuate_collection_set() const { |
399 |
const double sum_ms = _root_region_scan_wait_time_ms + |
|
400 |
_recorded_young_cset_choice_time_ms + |
|
401 |
_recorded_non_young_cset_choice_time_ms + |
|
54843
25c329958c70
8200545: Improve filter for enqueued deferred cards
tschatzl
parents:
54713
diff
changeset
|
402 |
_cur_region_register_time + |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
403 |
_recorded_prepare_heap_roots_time_ms + |
46353
1df99120f158
8176885: Clear Claimed Marks log message at wrong location in the log
tschatzl
parents:
46340
diff
changeset
|
404 |
_recorded_clear_claimed_marks_time_ms; |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
405 |
|
42557 | 406 |
info_time("Pre Evacuate Collection Set", sum_ms); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
407 |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
408 |
if (_root_region_scan_wait_time_ms > 0.0) { |
42557 | 409 |
debug_time("Root Region Scan Waiting", _root_region_scan_wait_time_ms); |
410 |
} |
|
46330
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
411 |
debug_time("Prepare TLABs", _cur_prepare_tlab_time_ms); |
42557 | 412 |
debug_time("Choose Collection Set", (_recorded_young_cset_choice_time_ms + _recorded_non_young_cset_choice_time_ms)); |
54843
25c329958c70
8200545: Improve filter for enqueued deferred cards
tschatzl
parents:
54713
diff
changeset
|
413 |
debug_time("Region Register", _cur_region_register_time); |
42557 | 414 |
if (G1EagerReclaimHumongousObjects) { |
415 |
trace_count("Humongous Total", _cur_fast_reclaim_humongous_total); |
|
416 |
trace_count("Humongous Candidate", _cur_fast_reclaim_humongous_candidates); |
|
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
417 |
} |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
26701
diff
changeset
|
418 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
419 |
debug_time("Prepare Heap Roots", _recorded_prepare_heap_roots_time_ms); |
46353
1df99120f158
8176885: Clear Claimed Marks log message at wrong location in the log
tschatzl
parents:
46340
diff
changeset
|
420 |
if (_recorded_clear_claimed_marks_time_ms > 0.0) { |
1df99120f158
8176885: Clear Claimed Marks log message at wrong location in the log
tschatzl
parents:
46340
diff
changeset
|
421 |
debug_time("Clear Claimed Marks", _recorded_clear_claimed_marks_time_ms); |
1df99120f158
8176885: Clear Claimed Marks log message at wrong location in the log
tschatzl
parents:
46340
diff
changeset
|
422 |
} |
42557 | 423 |
return sum_ms; |
424 |
} |
|
425 |
||
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
426 |
double G1GCPhaseTimes::print_evacuate_optional_collection_set() const { |
58796
7608c17b7463
8232779: G1 current collection parallel time does not include optional evacuation
tschatzl
parents:
58777
diff
changeset
|
427 |
const double sum_ms = _cur_optional_evac_time_ms + _cur_optional_merge_heap_roots_time_ms; |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
428 |
if (sum_ms > 0) { |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
429 |
info_time("Merge Optional Heap Roots", _cur_optional_merge_heap_roots_time_ms); |
55722
5ee183a90e65
8227084: Add timing information for merge heap root preparation
tschatzl
parents:
55510
diff
changeset
|
430 |
|
5ee183a90e65
8227084: Add timing information for merge heap root preparation
tschatzl
parents:
55510
diff
changeset
|
431 |
debug_time("Prepare Optional Merge Heap Roots", _cur_optional_prepare_merge_heap_roots_time_ms); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
432 |
debug_phase(_gc_par_phases[OptMergeRS]); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
433 |
|
58796
7608c17b7463
8232779: G1 current collection parallel time does not include optional evacuation
tschatzl
parents:
58777
diff
changeset
|
434 |
info_time("Evacuate Optional Collection Set", _cur_optional_evac_time_ms); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
435 |
debug_phase(_gc_par_phases[OptScanHR]); |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
436 |
debug_phase(_gc_par_phases[OptObjCopy]); |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
437 |
debug_phase(_gc_par_phases[OptCodeRoots]); |
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
438 |
debug_phase(_gc_par_phases[OptTermination]); |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
439 |
} |
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
440 |
return sum_ms; |
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
441 |
} |
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
442 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
443 |
double G1GCPhaseTimes::print_evacuate_initial_collection_set() const { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
444 |
info_time("Merge Heap Roots", _cur_merge_heap_roots_time_ms); |
42557 | 445 |
|
55722
5ee183a90e65
8227084: Add timing information for merge heap root preparation
tschatzl
parents:
55510
diff
changeset
|
446 |
debug_time("Prepare Merge Heap Roots", _cur_prepare_merge_heap_roots_time_ms); |
55723
95706898c3ea
8227089: Add timing information for merging humongous remembered sets
tschatzl
parents:
55722
diff
changeset
|
447 |
debug_phase(_gc_par_phases[MergeER]); |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
448 |
debug_phase(_gc_par_phases[MergeRS]); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
449 |
if (G1HotCardCache::default_use_cache()) { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
450 |
debug_phase(_gc_par_phases[MergeHCC]); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
451 |
} |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
452 |
debug_phase(_gc_par_phases[MergeLB]); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
453 |
|
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
454 |
info_time("Evacuate Collection Set", _cur_collection_initial_evac_time_ms); |
42557 | 455 |
|
36374 | 456 |
trace_phase(_gc_par_phases[GCWorkerStart], false); |
457 |
debug_phase(_gc_par_phases[ExtRootScan]); |
|
54713
040bf087ae39
8221359: Eliminate SATBMarkQueueSet::filter_thread_buffers
kbarrett
parents:
54669
diff
changeset
|
458 |
for (int i = ExtRootScanSubPhasesFirst; i <= ExtRootScanSubPhasesLast; i++) { |
36374 | 459 |
trace_phase(_gc_par_phases[i]); |
460 |
} |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
461 |
debug_phase(_gc_par_phases[ScanHR]); |
36374 | 462 |
debug_phase(_gc_par_phases[CodeRoots]); |
463 |
debug_phase(_gc_par_phases[ObjCopy]); |
|
464 |
debug_phase(_gc_par_phases[Termination]); |
|
465 |
debug_phase(_gc_par_phases[Other]); |
|
466 |
debug_phase(_gc_par_phases[GCWorkerTotal]); |
|
467 |
trace_phase(_gc_par_phases[GCWorkerEnd], false); |
|
468 |
||
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
469 |
return _cur_collection_initial_evac_time_ms + _cur_merge_heap_roots_time_ms; |
42557 | 470 |
} |
471 |
||
472 |
double G1GCPhaseTimes::print_post_evacuate_collection_set() const { |
|
473 |
const double evac_fail_handling = _cur_evac_fail_recalc_used + |
|
46670
55a3c36b64b2
8183539: Remove G1RemSet::_into_cset_dirty_card_queue_set
ehelin
parents:
46571
diff
changeset
|
474 |
_cur_evac_fail_remove_self_forwards; |
59198
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
475 |
assert(_gc_par_phases[MergePSS]->get(0) != WorkerDataArray<double>::uninitialized(), "must be set"); |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
476 |
const double merge_pss = _gc_par_phases[MergePSS]->get(0) * MILLIUNITS; |
42557 | 477 |
const double sum_ms = evac_fail_handling + |
478 |
_cur_collection_code_root_fixup_time_ms + |
|
479 |
_recorded_preserve_cm_referents_time_ms + |
|
480 |
_cur_ref_proc_time_ms + |
|
51546
b9f6a4427da9
8072498: Multi-thread JNI weak reference processing
kbarrett
parents:
51332
diff
changeset
|
481 |
(_weak_phase_times.total_time_sec() * MILLIUNITS) + |
42557 | 482 |
_cur_clear_ct_time_ms + |
59198
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
483 |
merge_pss + |
42557 | 484 |
_cur_strong_code_root_purge_time_ms + |
485 |
_recorded_redirty_logged_cards_time_ms + |
|
486 |
_recorded_total_free_cset_time_ms + |
|
487 |
_cur_fast_reclaim_humongous_time_ms + |
|
488 |
_cur_expand_heap_time_ms + |
|
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
489 |
_cur_string_deduplication_time_ms; |
42557 | 490 |
|
491 |
info_time("Post Evacuate Collection Set", sum_ms); |
|
492 |
||
493 |
debug_time("Code Roots Fixup", _cur_collection_code_root_fixup_time_ms); |
|
494 |
||
49966
cac87c923310
8202018: Move card table clear before enqueuing pending references
tschatzl
parents:
49964
diff
changeset
|
495 |
debug_time("Clear Card Table", _cur_clear_ct_time_ms); |
cac87c923310
8202018: Move card table clear before enqueuing pending references
tschatzl
parents:
49964
diff
changeset
|
496 |
|
46795
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
497 |
debug_time_for_reference("Reference Processing", _cur_ref_proc_time_ms); |
623a5e42deb6
8173335: Improve logging for j.l.ref.reference processing
sangheki
parents:
46778
diff
changeset
|
498 |
_ref_phase_times.print_all_references(2, false); |
51546
b9f6a4427da9
8072498: Multi-thread JNI weak reference processing
kbarrett
parents:
51332
diff
changeset
|
499 |
_weak_phase_times.log_print(2); |
49810
b5d5e53232ce
8201596: java.lang.ref.Reference processing total time logging broken
tschatzl
parents:
47799
diff
changeset
|
500 |
|
23472 | 501 |
if (G1StringDedup::is_enabled()) { |
53536
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
502 |
debug_time("String Deduplication", _cur_string_deduplication_time_ms); |
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
503 |
debug_phase(_gc_par_phases[StringDedupQueueFixup], 1); |
482109fae02b
8213229: Investigate treating StringTable as weak in young collections
tschatzl
parents:
52897
diff
changeset
|
504 |
debug_phase(_gc_par_phases[StringDedupTableFixup], 1); |
23472 | 505 |
} |
36374 | 506 |
|
23455
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
23454
diff
changeset
|
507 |
if (G1CollectedHeap::heap()->evacuation_failed()) { |
42557 | 508 |
debug_time("Evacuation Failure", evac_fail_handling); |
509 |
trace_time("Recalculate Used", _cur_evac_fail_recalc_used); |
|
510 |
trace_time("Remove Self Forwards",_cur_evac_fail_remove_self_forwards); |
|
23455
e541bff96524
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
23454
diff
changeset
|
511 |
} |
42557 | 512 |
|
59198
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
513 |
debug_phase(_gc_par_phases[MergePSS], 0); |
42557 | 514 |
debug_time("Code Roots Purge", _cur_strong_code_root_purge_time_ms); |
515 |
||
516 |
debug_time("Redirty Cards", _recorded_redirty_logged_cards_time_ms); |
|
46340
9c2be834d6e3
8176881: DerivedPointerTable Update log message in wrong order in regards to Redirty Cards
tschatzl
parents:
46330
diff
changeset
|
517 |
trace_phase(_gc_par_phases[RedirtyCards]); |
47799 | 518 |
#if COMPILER2_OR_JVMCI |
46330
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
519 |
debug_time("DerivedPointerTable Update", _cur_derived_pointer_table_update_time_ms); |
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
520 |
#endif |
42048
c1f066b53dd7
8160055: Misplaced call to ClassLoaderDataGraph::clear_claimed_marks during initial mark
jprovino
parents:
39979
diff
changeset
|
521 |
|
42557 | 522 |
debug_time("Free Collection Set", _recorded_total_free_cset_time_ms); |
523 |
trace_time("Free Collection Set Serial", _recorded_serial_free_cset_time_ms); |
|
524 |
trace_phase(_gc_par_phases[YoungFreeCSet]); |
|
525 |
trace_phase(_gc_par_phases[NonYoungFreeCSet]); |
|
526 |
||
28379
e6784fc8fff2
8048179: Early reclaim of large objects that are referenced by a few objects
tschatzl
parents:
27251
diff
changeset
|
527 |
if (G1EagerReclaimHumongousObjects) { |
42557 | 528 |
debug_time("Humongous Reclaim", _cur_fast_reclaim_humongous_time_ms); |
529 |
trace_count("Humongous Reclaimed", _cur_fast_reclaim_humongous_reclaimed); |
|
25889
221296ac4359
8027959: Early reclamation of large objects in G1
tschatzl
parents:
25492
diff
changeset
|
530 |
} |
46330
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
531 |
debug_time("Start New Collection Set", _recorded_start_new_cset_time_ms); |
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
532 |
if (UseTLAB && ResizeTLAB) { |
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
533 |
debug_time("Resize TLABs", _cur_resize_tlab_time_ms); |
40e2718fac10
8155094: Add logging for long lasting methods found in JDK-8152948
tschatzl
parents:
42650
diff
changeset
|
534 |
} |
42557 | 535 |
debug_time("Expand Heap After Collection", _cur_expand_heap_time_ms); |
536 |
||
537 |
||
538 |
return sum_ms; |
|
539 |
} |
|
540 |
||
541 |
void G1GCPhaseTimes::print_other(double accounted_ms) const { |
|
542 |
info_time("Other", _gc_pause_time_ms - accounted_ms); |
|
543 |
} |
|
544 |
||
545 |
void G1GCPhaseTimes::print() { |
|
546 |
note_gc_end(); |
|
547 |
||
548 |
if (_cur_verify_before_time_ms > 0.0) { |
|
549 |
debug_time("Verify Before", _cur_verify_before_time_ms); |
|
550 |
} |
|
551 |
||
552 |
double accounted_ms = 0.0; |
|
553 |
accounted_ms += print_pre_evacuate_collection_set(); |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
554 |
accounted_ms += print_evacuate_initial_collection_set(); |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
555 |
accounted_ms += print_evacuate_optional_collection_set(); |
42557 | 556 |
accounted_ms += print_post_evacuate_collection_set(); |
557 |
print_other(accounted_ms); |
|
558 |
||
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13288
diff
changeset
|
559 |
if (_cur_verify_after_time_ms > 0.0) { |
42557 | 560 |
debug_time("Verify After", _cur_verify_after_time_ms); |
13516
f7adc27fb367
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
13288
diff
changeset
|
561 |
} |
13288
331d5b6725f3
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
diff
changeset
|
562 |
} |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
563 |
|
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
564 |
const char* G1GCPhaseTimes::phase_name(GCParPhases phase) { |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
565 |
static const char* names[] = { |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
566 |
"GCWorkerStart", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
567 |
"ExtRootScan", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
568 |
"ThreadRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
569 |
"UniverseRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
570 |
"JNIRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
571 |
"ObjectSynchronizerRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
572 |
"ManagementRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
573 |
"SystemDictionaryRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
574 |
"CLDGRoots", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
575 |
"JVMTIRoots", |
54669
ad45b3802d4e
8220623: [JVMCI] Update JVMCI to support JVMCI based Compiler compiled into shared library
kvn
parents:
54465
diff
changeset
|
576 |
AOT_ONLY("AOTCodeRoots" COMMA) |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
577 |
"CMRefRoots", |
55723
95706898c3ea
8227089: Add timing information for merging humongous remembered sets
tschatzl
parents:
55722
diff
changeset
|
578 |
"MergeER", |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
579 |
"MergeRS", |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
580 |
"OptMergeRS", |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
581 |
"MergeLB", |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
582 |
"MergeHCC", |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
583 |
"ScanHR", |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
584 |
"OptScanHR", |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
585 |
"CodeRoots", |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
586 |
"OptCodeRoots", |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
587 |
"ObjCopy", |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
588 |
"OptObjCopy", |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
589 |
"Termination", |
54465
c4f16445675a
8218668: Clean up evacuation of optional collection set
tschatzl
parents:
53984
diff
changeset
|
590 |
"OptTermination", |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
591 |
"Other", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
592 |
"GCWorkerTotal", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
593 |
"GCWorkerEnd", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
594 |
"StringDedupQueueFixup", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
595 |
"StringDedupTableFixup", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
596 |
"RedirtyCards", |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
597 |
"YoungFreeCSet", |
59198
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
598 |
"NonYoungFreeCSet", |
92c98aa0f801
8228609: G1 copy cost prediction uses used vs. actual copied byte
tschatzl
parents:
58796
diff
changeset
|
599 |
"MergePSS" |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
600 |
//GCParPhasesSentinel only used to tell end of enum |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
601 |
}; |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
602 |
|
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
603 |
STATIC_ASSERT(ARRAY_SIZE(names) == G1GCPhaseTimes::GCParPhasesSentinel); // GCParPhases enum and corresponding string array should have the same "length", this tries to assert it |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
604 |
|
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
605 |
return names[phase]; |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
606 |
} |
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
607 |
|
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
608 |
G1EvacPhaseWithTrimTimeTracker::G1EvacPhaseWithTrimTimeTracker(G1ParScanThreadState* pss, Tickspan& total_time, Tickspan& trim_time) : |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
609 |
_pss(pss), |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
610 |
_start(Ticks::now()), |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
611 |
_total_time(total_time), |
50438
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
612 |
_trim_time(trim_time), |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
613 |
_stopped(false) { |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
614 |
|
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
615 |
assert(_pss->trim_ticks().value() == 0, "Possibly remaining trim ticks left over from previous use"); |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
616 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
617 |
|
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
618 |
G1EvacPhaseWithTrimTimeTracker::~G1EvacPhaseWithTrimTimeTracker() { |
50438
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
619 |
if (!_stopped) { |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
620 |
stop(); |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
621 |
} |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
622 |
} |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
623 |
|
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
624 |
void G1EvacPhaseWithTrimTimeTracker::stop() { |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
625 |
assert(!_stopped, "Should only be called once"); |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
626 |
_total_time += (Ticks::now() - _start) - _pss->trim_ticks(); |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
627 |
_trim_time += _pss->trim_ticks(); |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
628 |
_pss->reset_trim_ticks(); |
50438
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
629 |
_stopped = true; |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
630 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
631 |
|
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
632 |
G1GCParPhaseTimesTracker::G1GCParPhaseTimesTracker(G1GCPhaseTimes* phase_times, G1GCPhaseTimes::GCParPhases phase, uint worker_id, bool must_record) : |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
633 |
_start_time(), _phase(phase), _phase_times(phase_times), _worker_id(worker_id), _event(), _must_record(must_record) { |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
634 |
if (_phase_times != NULL) { |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
635 |
_start_time = Ticks::now(); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
636 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
637 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
638 |
|
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
639 |
G1GCParPhaseTimesTracker::~G1GCParPhaseTimesTracker() { |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
640 |
if (_phase_times != NULL) { |
55510
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
641 |
if (_must_record) { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
642 |
_phase_times->record_time_secs(_phase, _worker_id, (Ticks::now() - _start_time).seconds()); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
643 |
} else { |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
644 |
_phase_times->record_or_add_time_secs(_phase, _worker_id, (Ticks::now() - _start_time).seconds()); |
3e31a8beaae4
8213108: Improve work distribution during remembered set scan
tschatzl
parents:
54843
diff
changeset
|
645 |
} |
51877
5f931e3e7a63
8196341: Add JFR events for parallel phases of G1
lkorinth
parents:
51546
diff
changeset
|
646 |
_event.commit(GCId::current(), _worker_id, G1GCPhaseTimes::phase_name(_phase)); |
29680
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
647 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
648 |
} |
e5203ed6d805
8074037: Refactor the G1GCPhaseTime logging to make it easier to add new phases
brutisso
parents:
28379
diff
changeset
|
649 |
|
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
650 |
G1EvacPhaseTimesTracker::G1EvacPhaseTimesTracker(G1GCPhaseTimes* phase_times, |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
651 |
G1ParScanThreadState* pss, |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
652 |
G1GCPhaseTimes::GCParPhases phase, |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
653 |
uint worker_id) : |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
654 |
G1GCParPhaseTimesTracker(phase_times, phase, worker_id), |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
655 |
_total_time(), |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
656 |
_trim_time(), |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
657 |
_trim_tracker(pss, _total_time, _trim_time) { |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
658 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
659 |
|
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
660 |
G1EvacPhaseTimesTracker::~G1EvacPhaseTimesTracker() { |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
661 |
if (_phase_times != NULL) { |
50438
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
662 |
// Explicitly stop the trim tracker since it's not yet destructed. |
66d0ded78cce
8204287: Phase timings not updated correctly after JDK-6672778
sjohanss
parents:
50113
diff
changeset
|
663 |
_trim_tracker.stop(); |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
664 |
// Exclude trim time by increasing the start time. |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
665 |
_start_time += _trim_time; |
52897
495c05ee2a9a
8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
sjohanss
parents:
52308
diff
changeset
|
666 |
_phase_times->record_or_add_time_secs(G1GCPhaseTimes::ObjCopy, _worker_id, _trim_time.seconds()); |
49911
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
667 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
668 |
} |
358be4680d12
6672778: G1 should trim task queues more aggressively during evacuation pauses
tschatzl
parents:
49810
diff
changeset
|
669 |