Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 20211:82693fb204a5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet Summary: The test incorrectly assumed that it had been started with no other previous compilation activity. Fix this by allowing multiple code root free chunk lists, and use one separate from the global one to perform the test. Reviewed-by: brutisso
author tschatzl
date Wed, 16 Apr 2014 10:14:50 +0200
parents c49dcaf78a65
children ab5fbf410512
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1 /*
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
7 * published by the Free Software Foundation.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
8 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
13 * accompanied this code).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
14 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1547
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1547
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1547
diff changeset
21 * questions.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
22 *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
23 */
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
26 #include "classfile/symbolTable.hpp"
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
27 #include "gc_implementation/g1/concurrentMark.inline.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
28 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
30 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
3914
20213c8a3c40 7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents: 3867
diff changeset
31 #include "gc_implementation/g1/g1ErgoVerbose.hpp"
6007
5c86f8211d1e 7160728: Introduce an extra logging level for G1 logging
brutisso
parents: 5988
diff changeset
32 #include "gc_implementation/g1/g1Log.hpp"
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
33 #include "gc_implementation/g1/g1OopClosures.inline.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
34 #include "gc_implementation/g1/g1RemSet.hpp"
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
35 #include "gc_implementation/g1/heapRegion.inline.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
36 #include "gc_implementation/g1/heapRegionRemSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
37 #include "gc_implementation/g1/heapRegionSeq.inline.hpp"
2125
7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents: 2037
diff changeset
38 #include "gc_implementation/shared/vmGCOperations.hpp"
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
39 #include "gc_implementation/shared/gcTimer.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
40 #include "gc_implementation/shared/gcTrace.hpp"
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
41 #include "gc_implementation/shared/gcTraceTime.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
42 #include "memory/genOopClosures.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
43 #include "memory/referencePolicy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
44 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
45 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
46 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1885
diff changeset
47 #include "runtime/java.hpp"
20198
c49dcaf78a65 8042737: Introduce umbrella header prefetch.inline.hpp
goetz
parents: 20192
diff changeset
48 #include "runtime/prefetch.inline.hpp"
6197
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 6027
diff changeset
49 #include "services/memTracker.hpp"
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
50
4828
851b58c26def 7130334: G1: Change comments and error messages that refer to CMS in g1/concurrentMark.cpp/hpp
brutisso
parents: 4827
diff changeset
51 // Concurrent marking bit map wrapper
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
52
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
53 CMBitMapRO::CMBitMapRO(int shifter) :
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
54 _bm(),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
55 _shifter(shifter) {
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
56 _bmStartWord = 0;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
57 _bmWordSize = 0;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
58 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
59
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
60 HeapWord* CMBitMapRO::getNextMarkedWordAddress(HeapWord* addr,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
61 HeapWord* limit) const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
62 // First we must round addr *up* to a possible object boundary.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
63 addr = (HeapWord*)align_size_up((intptr_t)addr,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
64 HeapWordSize << _shifter);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
65 size_t addrOffset = heapWordToOffset(addr);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
66 if (limit == NULL) {
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
67 limit = _bmStartWord + _bmWordSize;
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
68 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
69 size_t limitOffset = heapWordToOffset(limit);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
70 size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
71 HeapWord* nextAddr = offsetToHeapWord(nextOffset);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
72 assert(nextAddr >= addr, "get_next_one postcondition");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
73 assert(nextAddr == limit || isMarked(nextAddr),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
74 "get_next_one postcondition");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
75 return nextAddr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
76 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
77
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
78 HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(HeapWord* addr,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
79 HeapWord* limit) const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
80 size_t addrOffset = heapWordToOffset(addr);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
81 if (limit == NULL) {
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
82 limit = _bmStartWord + _bmWordSize;
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
83 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
84 size_t limitOffset = heapWordToOffset(limit);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
85 size_t nextOffset = _bm.get_next_zero_offset(addrOffset, limitOffset);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
86 HeapWord* nextAddr = offsetToHeapWord(nextOffset);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
87 assert(nextAddr >= addr, "get_next_one postcondition");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
88 assert(nextAddr == limit || !isMarked(nextAddr),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
89 "get_next_one postcondition");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
90 return nextAddr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
91 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
92
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
93 int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
94 assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
95 return (int) (diff >> _shifter);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
96 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
97
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
98 #ifndef PRODUCT
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
99 bool CMBitMapRO::covers(ReservedSpace heap_rs) const {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
100 // assert(_bm.map() == _virtual_space.low(), "map inconsistency");
6750
859cd1a76f8a 7197906: BlockOffsetArray::power_to_cards_back() needs to handle > 32 bit shifts
brutisso
parents: 6725
diff changeset
101 assert(((size_t)_bm.size() * ((size_t)1 << _shifter)) == _bmWordSize,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
102 "size inconsistency");
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
103 return _bmStartWord == (HeapWord*)(heap_rs.base()) &&
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
104 _bmWordSize == heap_rs.size()>>LogHeapWordSize;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
105 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
106 #endif
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
107
9076
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
108 void CMBitMapRO::print_on_error(outputStream* st, const char* prefix) const {
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
109 _bm.print_on_error(st, prefix);
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
110 }
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
111
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
112 bool CMBitMap::allocate(ReservedSpace heap_rs) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
113 _bmStartWord = (HeapWord*)(heap_rs.base());
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
114 _bmWordSize = heap_rs.size()/HeapWordSize; // heap_rs.size() is in bytes
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
115 ReservedSpace brs(ReservedSpace::allocation_align_size_up(
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
116 (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1));
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
117 if (!brs.is_reserved()) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
118 warning("ConcurrentMark marking bit map allocation failure");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
119 return false;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
120 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
121 MemTracker::record_virtual_memory_type((address)brs.base(), mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
122 // For now we'll just commit all of the bit map up front.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
123 // Later on we'll try to be more parsimonious with swap.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
124 if (!_virtual_space.initialize(brs, brs.size())) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
125 warning("ConcurrentMark marking bit map backing store failure");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
126 return false;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
127 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
128 assert(_virtual_space.committed_size() == brs.size(),
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
129 "didn't reserve backing store for all of concurrent marking bit map?");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
130 _bm.set_map((uintptr_t*)_virtual_space.low());
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
131 assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >=
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
132 _bmWordSize, "inconsistency in bit map sizing");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
133 _bm.set_size(_bmWordSize >> _shifter);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
134 return true;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
135 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
136
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
137 void CMBitMap::clearAll() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
138 _bm.clear();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
139 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
140 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
141
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
142 void CMBitMap::markRange(MemRegion mr) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
143 mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
144 assert(!mr.is_empty(), "unexpected empty region");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
145 assert((offsetToHeapWord(heapWordToOffset(mr.end())) ==
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
146 ((HeapWord *) mr.end())),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
147 "markRange memory region end is not card aligned");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
148 // convert address range into offset range
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
149 _bm.at_put_range(heapWordToOffset(mr.start()),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
150 heapWordToOffset(mr.end()), true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
151 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
152
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
153 void CMBitMap::clearRange(MemRegion mr) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
154 mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
155 assert(!mr.is_empty(), "unexpected empty region");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
156 // convert address range into offset range
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
157 _bm.at_put_range(heapWordToOffset(mr.start()),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
158 heapWordToOffset(mr.end()), false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
159 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
160
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
161 MemRegion CMBitMap::getAndClearMarkedRegion(HeapWord* addr,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
162 HeapWord* end_addr) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
163 HeapWord* start = getNextMarkedWordAddress(addr);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
164 start = MIN2(start, end_addr);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
165 HeapWord* end = getNextUnmarkedWordAddress(start);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
166 end = MIN2(end, end_addr);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
167 assert(start <= end, "Consistency check");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
168 MemRegion mr(start, end);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
169 if (!mr.is_empty()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
170 clearRange(mr);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
171 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
172 return mr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
173 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
174
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
175 CMMarkStack::CMMarkStack(ConcurrentMark* cm) :
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
176 _base(NULL), _cm(cm)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
177 #ifdef ASSERT
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
178 , _drain_in_progress(false)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
179 , _drain_in_progress_yields(false)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
180 #endif
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
181 {}
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
182
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
183 bool CMMarkStack::allocate(size_t capacity) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
184 // allocate a stack of the requisite depth
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
185 ReservedSpace rs(ReservedSpace::allocation_align_size_up(capacity * sizeof(oop)));
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
186 if (!rs.is_reserved()) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
187 warning("ConcurrentMark MarkStack allocation failure");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
188 return false;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
189 }
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
190 MemTracker::record_virtual_memory_type((address)rs.base(), mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
191 if (!_virtual_space.initialize(rs, rs.size())) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
192 warning("ConcurrentMark MarkStack backing store failure");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
193 // Release the virtual memory reserved for the marking stack
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
194 rs.release();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
195 return false;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
196 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
197 assert(_virtual_space.committed_size() == rs.size(),
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
198 "Didn't reserve backing store for all of ConcurrentMark stack?");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
199 _base = (oop*) _virtual_space.low();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
200 setEmpty();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
201 _capacity = (jint) capacity;
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
202 _saved_index = -1;
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
203 _should_expand = false;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
204 NOT_PRODUCT(_max_depth = 0);
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
205 return true;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
206 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
207
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
208 void CMMarkStack::expand() {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
209 // Called, during remark, if we've overflown the marking stack during marking.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
210 assert(isEmpty(), "stack should been emptied while handling overflow");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
211 assert(_capacity <= (jint) MarkStackSizeMax, "stack bigger than permitted");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
212 // Clear expansion flag
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
213 _should_expand = false;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
214 if (_capacity == (jint) MarkStackSizeMax) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
215 if (PrintGCDetails && Verbose) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
216 gclog_or_tty->print_cr(" (benign) Can't expand marking stack capacity, at max size limit");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
217 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
218 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
219 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
220 // Double capacity if possible
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
221 jint new_capacity = MIN2(_capacity*2, (jint) MarkStackSizeMax);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
222 // Do not give up existing stack until we have managed to
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
223 // get the double capacity that we desired.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
224 ReservedSpace rs(ReservedSpace::allocation_align_size_up(new_capacity *
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
225 sizeof(oop)));
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
226 if (rs.is_reserved()) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
227 // Release the backing store associated with old stack
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
228 _virtual_space.release();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
229 // Reinitialize virtual space for new stack
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
230 if (!_virtual_space.initialize(rs, rs.size())) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
231 fatal("Not enough swap for expanded marking stack capacity");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
232 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
233 _base = (oop*)(_virtual_space.low());
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
234 _index = 0;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
235 _capacity = new_capacity;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
236 } else {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
237 if (PrintGCDetails && Verbose) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
238 // Failed to double capacity, continue;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
239 gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from "
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
240 SIZE_FORMAT"K to " SIZE_FORMAT"K",
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
241 _capacity / K, new_capacity / K);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
242 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
243 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
244 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
245
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
246 void CMMarkStack::set_should_expand() {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
247 // If we're resetting the marking state because of an
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
248 // marking stack overflow, record that we should, if
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
249 // possible, expand the stack.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
250 _should_expand = _cm->has_overflown();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
251 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
252
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
253 CMMarkStack::~CMMarkStack() {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
254 if (_base != NULL) {
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
255 _base = NULL;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
256 _virtual_space.release();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
257 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
258 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
259
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
260 void CMMarkStack::par_push(oop ptr) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
261 while (true) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
262 if (isFull()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
263 _overflow = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
264 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
265 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
266 // Otherwise...
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
267 jint index = _index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
268 jint next_index = index+1;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
269 jint res = Atomic::cmpxchg(next_index, &_index, index);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
270 if (res == index) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
271 _base[index] = ptr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
272 // Note that we don't maintain this atomically. We could, but it
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
273 // doesn't seem necessary.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
274 NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
275 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
276 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
277 // Otherwise, we need to try again.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
278 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
279 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
280
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
281 void CMMarkStack::par_adjoin_arr(oop* ptr_arr, int n) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
282 while (true) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
283 if (isFull()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
284 _overflow = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
285 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
286 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
287 // Otherwise...
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
288 jint index = _index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
289 jint next_index = index + n;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
290 if (next_index > _capacity) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
291 _overflow = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
292 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
293 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
294 jint res = Atomic::cmpxchg(next_index, &_index, index);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
295 if (res == index) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
296 for (int i = 0; i < n; i++) {
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
297 int ind = index + i;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
298 assert(ind < _capacity, "By overflow test above.");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
299 _base[ind] = ptr_arr[i];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
300 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
301 NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
302 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
303 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
304 // Otherwise, we need to try again.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
305 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
306 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
307
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
308 void CMMarkStack::par_push_arr(oop* ptr_arr, int n) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
309 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
310 jint start = _index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
311 jint next_index = start + n;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
312 if (next_index > _capacity) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
313 _overflow = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
314 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
315 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
316 // Otherwise.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
317 _index = next_index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
318 for (int i = 0; i < n; i++) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
319 int ind = start + i;
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
320 assert(ind < _capacity, "By overflow test above.");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
321 _base[ind] = ptr_arr[i];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
322 }
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
323 NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
324 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
325
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
326 bool CMMarkStack::par_pop_arr(oop* ptr_arr, int max, int* n) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
327 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
328 jint index = _index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
329 if (index == 0) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
330 *n = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
331 return false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
332 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
333 int k = MIN2(max, index);
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
334 jint new_ind = index - k;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
335 for (int j = 0; j < k; j++) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
336 ptr_arr[j] = _base[new_ind + j];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
337 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
338 _index = new_ind;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
339 *n = k;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
340 return true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
341 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
342 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
343
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
344 template<class OopClosureClass>
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
345 bool CMMarkStack::drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
346 assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
347 || SafepointSynchronize::is_at_safepoint(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
348 "Drain recursion must be yield-safe.");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
349 bool res = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
350 debug_only(_drain_in_progress = true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
351 debug_only(_drain_in_progress_yields = yield_after);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
352 while (!isEmpty()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
353 oop newOop = pop();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
354 assert(G1CollectedHeap::heap()->is_in_reserved(newOop), "Bad pop");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
355 assert(newOop->is_oop(), "Expected an oop");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
356 assert(bm == NULL || bm->isMarked((HeapWord*)newOop),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
357 "only grey objects on this stack");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
358 newOop->oop_iterate(cl);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
359 if (yield_after && _cm->do_yield_check()) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
360 res = false;
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
361 break;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
362 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
363 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
364 debug_only(_drain_in_progress = false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
365 return res;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
366 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
367
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
368 void CMMarkStack::note_start_of_gc() {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
369 assert(_saved_index == -1,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
370 "note_start_of_gc()/end_of_gc() bracketed incorrectly");
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
371 _saved_index = _index;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
372 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
373
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
374 void CMMarkStack::note_end_of_gc() {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
375 // This is intentionally a guarantee, instead of an assert. If we
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
376 // accidentally add something to the mark stack during GC, it
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
377 // will be a correctness issue so it's better if we crash. we'll
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
378 // only check this once per GC anyway, so it won't be a performance
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
379 // issue in any way.
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
380 guarantee(_saved_index == _index,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
381 err_msg("saved index: %d index: %d", _saved_index, _index));
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
382 _saved_index = -1;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
383 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
384
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
385 void CMMarkStack::oops_do(OopClosure* f) {
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
386 assert(_saved_index == _index,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
387 err_msg("saved index: %d index: %d", _saved_index, _index));
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
388 for (int i = 0; i < _index; i += 1) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
389 f->do_oop(&_base[i]);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
390 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
391 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
392
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
393 bool ConcurrentMark::not_yet_marked(oop obj) const {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6254
diff changeset
394 return _g1h->is_obj_ill(obj);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
395 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
396
4837
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
397 CMRootRegions::CMRootRegions() :
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
398 _young_list(NULL), _cm(NULL), _scan_in_progress(false),
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
399 _should_abort(false), _next_survivor(NULL) { }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
400
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
401 void CMRootRegions::init(G1CollectedHeap* g1h, ConcurrentMark* cm) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
402 _young_list = g1h->young_list();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
403 _cm = cm;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
404 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
405
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
406 void CMRootRegions::prepare_for_scan() {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
407 assert(!scan_in_progress(), "pre-condition");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
408
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
409 // Currently, only survivors can be root regions.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
410 assert(_next_survivor == NULL, "pre-condition");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
411 _next_survivor = _young_list->first_survivor_region();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
412 _scan_in_progress = (_next_survivor != NULL);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
413 _should_abort = false;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
414 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
415
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
416 HeapRegion* CMRootRegions::claim_next() {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
417 if (_should_abort) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
418 // If someone has set the should_abort flag, we return NULL to
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
419 // force the caller to bail out of their loop.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
420 return NULL;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
421 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
422
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
423 // Currently, only survivors can be root regions.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
424 HeapRegion* res = _next_survivor;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
425 if (res != NULL) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
426 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
427 // Read it again in case it changed while we were waiting for the lock.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
428 res = _next_survivor;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
429 if (res != NULL) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
430 if (res == _young_list->last_survivor_region()) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
431 // We just claimed the last survivor so store NULL to indicate
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
432 // that we're done.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
433 _next_survivor = NULL;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
434 } else {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
435 _next_survivor = res->get_next_young_region();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
436 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
437 } else {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
438 // Someone else claimed the last survivor while we were trying
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
439 // to take the lock so nothing else to do.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
440 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
441 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
442 assert(res == NULL || res->is_survivor(), "post-condition");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
443
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
444 return res;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
445 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
446
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
447 void CMRootRegions::scan_finished() {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
448 assert(scan_in_progress(), "pre-condition");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
449
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
450 // Currently, only survivors can be root regions.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
451 if (!_should_abort) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
452 assert(_next_survivor == NULL, "we should have claimed all survivors");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
453 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
454 _next_survivor = NULL;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
455
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
456 {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
457 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
458 _scan_in_progress = false;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
459 RootRegionScan_lock->notify_all();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
460 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
461 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
462
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
463 bool CMRootRegions::wait_until_scan_finished() {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
464 if (!scan_in_progress()) return false;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
465
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
466 {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
467 MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
468 while (scan_in_progress()) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
469 RootRegionScan_lock->wait(Mutex::_no_safepoint_check_flag);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
470 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
471 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
472 return true;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
473 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
474
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
475 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
476 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
477 #endif // _MSC_VER
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
478
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
479 uint ConcurrentMark::scale_parallel_threads(uint n_par_threads) {
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
480 return MAX2((n_par_threads + 2) / 4, 1U);
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
481 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
482
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
483 ConcurrentMark::ConcurrentMark(G1CollectedHeap* g1h, ReservedSpace heap_rs) :
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
484 _g1h(g1h),
12229
ff218fdb30ba 8021823: G1: Concurrent marking crashes with -XX:ObjectAlignmentInBytes>=32 in 64bit VMs
tschatzl
parents: 12080
diff changeset
485 _markBitMap1(log2_intptr(MinObjAlignment)),
ff218fdb30ba 8021823: G1: Concurrent marking crashes with -XX:ObjectAlignmentInBytes>=32 in 64bit VMs
tschatzl
parents: 12080
diff changeset
486 _markBitMap2(log2_intptr(MinObjAlignment)),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
487 _parallel_marking_threads(0),
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
488 _max_parallel_marking_threads(0),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
489 _sleep_factor(0.0),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
490 _marking_task_overhead(1.0),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
491 _cleanup_sleep_factor(0.0),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
492 _cleanup_task_overhead(1.0),
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
493 _cleanup_list("Cleanup List"),
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
494 _region_bm((BitMap::idx_t)(g1h->max_regions()), false /* in_resource_area*/),
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
495 _card_bm((heap_rs.size() + CardTableModRefBS::card_size - 1) >>
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
496 CardTableModRefBS::card_shift,
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
497 false /* in_resource_area*/),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
498
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
499 _prevMarkBitMap(&_markBitMap1),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
500 _nextMarkBitMap(&_markBitMap2),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
501
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
502 _markStack(this),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
503 // _finger set in set_non_marking_state
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
504
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
505 _max_worker_id(MAX2((uint)ParallelGCThreads, 1U)),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
506 // _active_tasks set in set_non_marking_state
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
507 // _tasks set inside the constructor
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
508 _task_queues(new CMTaskQueueSet((int) _max_worker_id)),
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
509 _terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
510
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
511 _has_overflown(false),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
512 _concurrent(false),
619
7ea5ca260b28 6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents: 470
diff changeset
513 _has_aborted(false),
20190
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
514 _aborted_gc_id(GCId::undefined()),
619
7ea5ca260b28 6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents: 470
diff changeset
515 _restart_for_overflow(false),
7ea5ca260b28 6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents: 470
diff changeset
516 _concurrent_marking_in_progress(false),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
517
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
518 // _verbose_level set below
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
519
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
520 _init_times(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
521 _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
522 _cleanup_times(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
523 _total_counting_time(0.0),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
524 _total_rs_scrub_time(0.0),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
525
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
526 _parallel_workers(NULL),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
527
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
528 _count_card_bitmaps(NULL),
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
529 _count_marked_bytes(NULL),
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
530 _completed_initialization(false) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
531 CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel;
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
532 if (verbose_level < no_verbose) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
533 verbose_level = no_verbose;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
534 }
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
535 if (verbose_level > high_verbose) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
536 verbose_level = high_verbose;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
537 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
538 _verbose_level = verbose_level;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
539
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
540 if (verbose_low()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
541 gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
542 "heap end = " INTPTR_FORMAT, p2i(_heap_start), p2i(_heap_end));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
543 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
544
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
545 if (!_markBitMap1.allocate(heap_rs)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
546 warning("Failed to allocate first CM bit map");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
547 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
548 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
549 if (!_markBitMap2.allocate(heap_rs)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
550 warning("Failed to allocate second CM bit map");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
551 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
552 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
553
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
554 // Create & start a ConcurrentMark thread.
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
555 _cmThread = new ConcurrentMarkThread(this);
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
556 assert(cmThread() != NULL, "CM Thread should have been created");
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
557 assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");
13437
1de8e5356754 8029326: G1 does not check if threads gets created
ehelin
parents: 12316
diff changeset
558 if (_cmThread->osthread() == NULL) {
1de8e5356754 8029326: G1 does not check if threads gets created
ehelin
parents: 12316
diff changeset
559 vm_shutdown_during_initialization("Could not create ConcurrentMarkThread");
1de8e5356754 8029326: G1 does not check if threads gets created
ehelin
parents: 12316
diff changeset
560 }
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
561
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
562 assert(CGC_lock != NULL, "Where's the CGC_lock?");
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
563 assert(_markBitMap1.covers(heap_rs), "_markBitMap1 inconsistency");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
564 assert(_markBitMap2.covers(heap_rs), "_markBitMap2 inconsistency");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
565
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
566 SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();
1282
b81f3572f355 6928059: G1: command line parameter renaming
tonyp
parents: 1111
diff changeset
567 satb_qs.set_buffer_size(G1SATBBufferSize);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
568
4837
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
569 _root_regions.init(_g1h, this);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
570
1284
5f1f51edaff6 6928081: G1: rename parameters common with CMS
jmasa
parents: 1282
diff changeset
571 if (ConcGCThreads > ParallelGCThreads) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
572 warning("Can't have more ConcGCThreads (" UINTX_FORMAT ") "
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
573 "than ParallelGCThreads (" UINTX_FORMAT ").",
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
574 ConcGCThreads, ParallelGCThreads);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
575 return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
576 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
577 if (ParallelGCThreads == 0) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
578 // if we are not running with any parallel GC threads we will not
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
579 // spawn any marking threads either
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
580 _parallel_marking_threads = 0;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
581 _max_parallel_marking_threads = 0;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
582 _sleep_factor = 0.0;
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
583 _marking_task_overhead = 1.0;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
584 } else {
8006
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
585 if (!FLAG_IS_DEFAULT(ConcGCThreads) && ConcGCThreads > 0) {
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
586 // Note: ConcGCThreads has precedence over G1MarkingOverheadPercent
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
587 // if both are set
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
588 _sleep_factor = 0.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
589 _marking_task_overhead = 1.0;
751
20c6f43950b5 6490395: G1: Tidy up command line flags.
johnc
parents: 647
diff changeset
590 } else if (G1MarkingOverheadPercent > 0) {
8006
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
591 // We will calculate the number of parallel marking threads based
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
592 // on a target overhead with respect to the soft real-time goal
751
20c6f43950b5 6490395: G1: Tidy up command line flags.
johnc
parents: 647
diff changeset
593 double marking_overhead = (double) G1MarkingOverheadPercent / 100.0;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
594 double overall_cm_overhead =
751
20c6f43950b5 6490395: G1: Tidy up command line flags.
johnc
parents: 647
diff changeset
595 (double) MaxGCPauseMillis * marking_overhead /
20c6f43950b5 6490395: G1: Tidy up command line flags.
johnc
parents: 647
diff changeset
596 (double) GCPauseIntervalMillis;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
597 double cpu_ratio = 1.0 / (double) os::processor_count();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
598 double marking_thread_num = ceil(overall_cm_overhead / cpu_ratio);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
599 double marking_task_overhead =
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
600 overall_cm_overhead / marking_thread_num *
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
601 (double) os::processor_count();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
602 double sleep_factor =
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
603 (1.0 - marking_task_overhead) / marking_task_overhead;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
604
8006
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
605 FLAG_SET_ERGO(uintx, ConcGCThreads, (uint) marking_thread_num);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
606 _sleep_factor = sleep_factor;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
607 _marking_task_overhead = marking_task_overhead;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
608 } else {
8006
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
609 // Calculate the number of parallel marking threads by scaling
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
610 // the number of parallel GC threads.
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
611 uint marking_thread_num = scale_parallel_threads((uint) ParallelGCThreads);
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
612 FLAG_SET_ERGO(uintx, ConcGCThreads, marking_thread_num);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
613 _sleep_factor = 0.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
614 _marking_task_overhead = 1.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
615 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
616
8006
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
617 assert(ConcGCThreads > 0, "Should have been set");
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
618 _parallel_marking_threads = (uint) ConcGCThreads;
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
619 _max_parallel_marking_threads = _parallel_marking_threads;
4700e77d44c1 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 7450
diff changeset
620
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
621 if (parallel_marking_threads() > 1) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
622 _cleanup_task_overhead = 1.0;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
623 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
624 _cleanup_task_overhead = marking_task_overhead();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
625 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
626 _cleanup_sleep_factor =
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
627 (1.0 - cleanup_task_overhead()) / cleanup_task_overhead();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
628
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
629 #if 0
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
630 gclog_or_tty->print_cr("Marking Threads %d", parallel_marking_threads());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
631 gclog_or_tty->print_cr("CM Marking Task Overhead %1.4lf", marking_task_overhead());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
632 gclog_or_tty->print_cr("CM Sleep Factor %1.4lf", sleep_factor());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
633 gclog_or_tty->print_cr("CL Marking Task Overhead %1.4lf", cleanup_task_overhead());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
634 gclog_or_tty->print_cr("CL Sleep Factor %1.4lf", cleanup_sleep_factor());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
635 #endif
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
636
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
637 guarantee(parallel_marking_threads() > 0, "peace of mind");
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
638 _parallel_workers = new FlexibleWorkGang("G1 Parallel Marking Threads",
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
639 _max_parallel_marking_threads, false, true);
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
640 if (_parallel_workers == NULL) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
641 vm_exit_during_initialization("Failed necessary allocation.");
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
642 } else {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
643 _parallel_workers->initialize_workers();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
644 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
645 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
646
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
647 if (FLAG_IS_DEFAULT(MarkStackSize)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
648 uintx mark_stack_size =
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
649 MIN2(MarkStackSizeMax,
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
650 MAX2(MarkStackSize, (uintx) (parallel_marking_threads() * TASKQUEUE_SIZE)));
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
651 // Verify that the calculated value for MarkStackSize is in range.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
652 // It would be nice to use the private utility routine from Arguments.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
653 if (!(mark_stack_size >= 1 && mark_stack_size <= MarkStackSizeMax)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
654 warning("Invalid value calculated for MarkStackSize (" UINTX_FORMAT "): "
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
655 "must be between " UINTX_FORMAT " and " UINTX_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
656 mark_stack_size, (uintx) 1, MarkStackSizeMax);
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
657 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
658 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
659 FLAG_SET_ERGO(uintx, MarkStackSize, mark_stack_size);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
660 } else {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
661 // Verify MarkStackSize is in range.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
662 if (FLAG_IS_CMDLINE(MarkStackSize)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
663 if (FLAG_IS_DEFAULT(MarkStackSizeMax)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
664 if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
665 warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT "): "
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
666 "must be between " UINTX_FORMAT " and " UINTX_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
667 MarkStackSize, (uintx) 1, MarkStackSizeMax);
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
668 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
669 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
670 } else if (FLAG_IS_CMDLINE(MarkStackSizeMax)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
671 if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
672 warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT ")"
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
673 " or for MarkStackSizeMax (" UINTX_FORMAT ")",
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
674 MarkStackSize, MarkStackSizeMax);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
675 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
676 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
677 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
678 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
679 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
680
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
681 if (!_markStack.allocate(MarkStackSize)) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
682 warning("Failed to allocate CM marking stack");
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
683 return;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
684 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
685
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
686 _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_worker_id, mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
687 _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
688
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
689 _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap, _max_worker_id, mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
690 _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_worker_id, mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
691
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
692 BitMap::idx_t card_bm_size = _card_bm.size();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
693
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
694 // so that the assertion in MarkingTaskQueue::task_queue doesn't fail
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
695 _active_tasks = _max_worker_id;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
696
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
697 size_t max_regions = (size_t) _g1h->max_regions();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
698 for (uint i = 0; i < _max_worker_id; ++i) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
699 CMTaskQueue* task_queue = new CMTaskQueue();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
700 task_queue->initialize();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
701 _task_queues->register_queue(i, task_queue);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
702
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
703 _count_card_bitmaps[i] = BitMap(card_bm_size, false);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
704 _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, max_regions, mtGC);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
705
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
706 _tasks[i] = new CMTask(i, this,
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
707 _count_marked_bytes[i],
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
708 &_count_card_bitmaps[i],
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
709 task_queue, _task_queues);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
710
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
711 _accum_task_vtime[i] = 0.0;
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
712 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
713
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
714 // Calculate the card number for the bottom of the heap. Used
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
715 // in biasing indexes into the accounting card bitmaps.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
716 _heap_bottom_card_num =
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
717 intptr_t(uintptr_t(_g1h->reserved_region().start()) >>
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
718 CardTableModRefBS::card_shift);
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
719
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
720 // Clear all the liveness counting data
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
721 clear_all_count_data();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
722
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
723 // so that the call below can read a sensible value
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
724 _heap_start = (HeapWord*) heap_rs.base();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
725 set_non_marking_state();
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
726 _completed_initialization = true;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
727 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
728
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
729 void ConcurrentMark::update_g1_committed(bool force) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
730 // If concurrent marking is not in progress, then we do not need to
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
731 // update _heap_end.
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
732 if (!concurrent_marking_in_progress() && !force) return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
733
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
734 MemRegion committed = _g1h->g1_committed();
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
735 assert(committed.start() == _heap_start, "start shouldn't change");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
736 HeapWord* new_end = committed.end();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
737 if (new_end > _heap_end) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
738 // The heap has been expanded.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
739
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
740 _heap_end = new_end;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
741 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
742 // Notice that the heap can also shrink. However, this only happens
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
743 // during a Full GC (at least currently) and the entire marking
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
744 // phase will bail out and the task will not be restarted. So, let's
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
745 // do nothing.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
746 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
747
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
748 void ConcurrentMark::reset() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
749 // Starting values for these two. This should be called in a STW
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
750 // phase. CM will be notified of any future g1_committed expansions
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
751 // will be at the end of evacuation pauses, when tasks are
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
752 // inactive.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
753 MemRegion committed = _g1h->g1_committed();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
754 _heap_start = committed.start();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
755 _heap_end = committed.end();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
756
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
757 // Separated the asserts so that we know which one fires.
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
758 assert(_heap_start != NULL, "heap bounds should look ok");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
759 assert(_heap_end != NULL, "heap bounds should look ok");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
760 assert(_heap_start < _heap_end, "heap bounds should look ok");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
761
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
762 // Reset all the marking data structures and any necessary flags
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
763 reset_marking_state();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
764
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
765 if (verbose_low()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
766 gclog_or_tty->print_cr("[global] resetting");
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
767 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
768
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
769 // We do reset all of them, since different phases will use
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
770 // different number of active threads. So, it's easiest to have all
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
771 // of them ready.
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
772 for (uint i = 0; i < _max_worker_id; ++i) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
773 _tasks[i]->reset(_nextMarkBitMap);
1835
4805b9f4779e 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 1833
diff changeset
774 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
775
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
776 // we need this to make sure that the flag is on during the evac
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
777 // pause with initial mark piggy-backed
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
778 set_concurrent_marking_in_progress();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
779 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
780
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
781
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
782 void ConcurrentMark::reset_marking_state(bool clear_overflow) {
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
783 _markStack.set_should_expand();
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
784 _markStack.setEmpty(); // Also clears the _markStack overflow flag
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
785 if (clear_overflow) {
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
786 clear_has_overflown();
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
787 } else {
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
788 assert(has_overflown(), "pre-condition");
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
789 }
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
790 _finger = _heap_start;
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
791
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
792 for (uint i = 0; i < _max_worker_id; ++i) {
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
793 CMTaskQueue* queue = _task_queues->queue(i);
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
794 queue->set_empty();
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
795 }
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
796 }
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
797
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
798 void ConcurrentMark::set_concurrency(uint active_tasks) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
799 assert(active_tasks <= _max_worker_id, "we should not have more");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
800
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
801 _active_tasks = active_tasks;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
802 // Need to update the three data structures below according to the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
803 // number of active threads for this phase.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
804 _terminator = ParallelTaskTerminator((int) active_tasks, _task_queues);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
805 _first_overflow_barrier_sync.set_n_workers((int) active_tasks);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
806 _second_overflow_barrier_sync.set_n_workers((int) active_tasks);
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
807 }
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
808
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
809 void ConcurrentMark::set_concurrency_and_phase(uint active_tasks, bool concurrent) {
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
810 set_concurrency(active_tasks);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
811
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
812 _concurrent = concurrent;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
813 // We propagate this to all tasks, not just the active ones.
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
814 for (uint i = 0; i < _max_worker_id; ++i)
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
815 _tasks[i]->set_concurrent(concurrent);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
816
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
817 if (concurrent) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
818 set_concurrent_marking_in_progress();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
819 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
820 // We currently assume that the concurrent flag has been set to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
821 // false before we start remark. At this point we should also be
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
822 // in a STW phase.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
823 assert(!concurrent_marking_in_progress(), "invariant");
17950
8a140676873f 8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents: 17949
diff changeset
824 assert(out_of_regions(),
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
825 err_msg("only way to get here: _finger: "PTR_FORMAT", _heap_end: "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
826 p2i(_finger), p2i(_heap_end)));
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
827 update_g1_committed(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
828 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
829 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
830
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
831 void ConcurrentMark::set_non_marking_state() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
832 // We set the global marking state to some default values when we're
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
833 // not doing marking.
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
834 reset_marking_state();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
835 _active_tasks = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
836 clear_concurrent_marking_in_progress();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
837 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
838
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
839 ConcurrentMark::~ConcurrentMark() {
4735
776173fc2df9 7125516: G1: ~ConcurrentMark() frees incorrectly
stefank
parents: 4728
diff changeset
840 // The ConcurrentMark instance is never freed.
776173fc2df9 7125516: G1: ~ConcurrentMark() frees incorrectly
stefank
parents: 4728
diff changeset
841 ShouldNotReachHere();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
842 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
843
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
844 void ConcurrentMark::clearNextBitmap() {
1359
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
845 G1CollectedHeap* g1h = G1CollectedHeap::heap();
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
846 G1CollectorPolicy* g1p = g1h->g1_policy();
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
847
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
848 // Make sure that the concurrent mark thread looks to still be in
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
849 // the current cycle.
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
850 guarantee(cmThread()->during_cycle(), "invariant");
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
851
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
852 // We are finishing up the current cycle by clearing the next
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
853 // marking bitmap and getting it ready for the next cycle. During
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
854 // this time no other cycle can start. So, let's make sure that this
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
855 // is the case.
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
856 guarantee(!g1h->mark_in_progress(), "invariant");
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
857
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
858 // clear the mark bitmap (no grey objects to start with).
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
859 // We need to do this in chunks and offer to yield in between
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
860 // each chunk.
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
861 HeapWord* start = _nextMarkBitMap->startWord();
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
862 HeapWord* end = _nextMarkBitMap->endWord();
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
863 HeapWord* cur = start;
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
864 size_t chunkSize = M;
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
865 while (cur < end) {
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
866 HeapWord* next = cur + chunkSize;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
867 if (next > end) {
1359
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
868 next = end;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
869 }
1359
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
870 MemRegion mr(cur,next);
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
871 _nextMarkBitMap->clearRange(mr);
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
872 cur = next;
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
873 do_yield_check();
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
874
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
875 // Repeat the asserts from above. We'll do them as asserts here to
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
876 // minimize their overhead on the product. However, we'll have
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
877 // them as guarantees at the beginning / end of the bitmap
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
878 // clearing to get some checking in the product.
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
879 assert(cmThread()->during_cycle(), "invariant");
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
880 assert(!g1h->mark_in_progress(), "invariant");
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
881 }
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
882
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
883 // Clear the liveness counting data
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
884 clear_all_count_data();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
885
1359
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
886 // Repeat the asserts from above.
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
887 guarantee(cmThread()->during_cycle(), "invariant");
23b1b27ac76c 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 1358
diff changeset
888 guarantee(!g1h->mark_in_progress(), "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
889 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
890
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
891 class NoteStartOfMarkHRClosure: public HeapRegionClosure {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
892 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
893 bool doHeapRegion(HeapRegion* r) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
894 if (!r->continuesHumongous()) {
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
895 r->note_start_of_marking();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
896 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
897 return false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
898 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
899 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
900
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
901 void ConcurrentMark::checkpointRootsInitialPre() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
902 G1CollectedHeap* g1h = G1CollectedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
903 G1CollectorPolicy* g1p = g1h->g1_policy();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
904
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
905 _has_aborted = false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
906
1547
fb1a39993f69 6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents: 1388
diff changeset
907 #ifndef PRODUCT
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
908 if (G1PrintReachableAtInitialMark) {
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
909 print_reachable("at-cycle-start",
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
910 VerifyOption_G1UsePrevMarking, true /* all */);
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
911 }
1547
fb1a39993f69 6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents: 1388
diff changeset
912 #endif
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
913
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
914 // Initialise marking structures. This has to be done in a STW phase.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
915 reset();
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
916
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
917 // For each region note start of marking.
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
918 NoteStartOfMarkHRClosure startcl;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
919 g1h->heap_region_iterate(&startcl);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
920 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
921
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
922
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
923 void ConcurrentMark::checkpointRootsInitialPost() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
924 G1CollectedHeap* g1h = G1CollectedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
925
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
926 // If we force an overflow during remark, the remark operation will
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
927 // actually abort and we'll restart concurrent marking. If we always
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
928 // force an oveflow during remark we'll never actually complete the
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
929 // marking phase. So, we initilize this here, at the start of the
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
930 // cycle, so that at the remaining overflow number will decrease at
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
931 // every remark and we'll eventually not need to cause one.
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
932 force_overflow_stw()->init();
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
933
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
934 // Start Concurrent Marking weak-reference discovery.
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
935 ReferenceProcessor* rp = g1h->ref_processor_cm();
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
936 // enable ("weak") refs discovery
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
937 rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
457
27a80744a83b 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 453
diff changeset
938 rp->setup_policy(false); // snapshot the soft ref policy to be used in this cycle
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
939
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
940 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
1317
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
941 // This is the start of the marking cycle, we're expected all
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
942 // threads to have SATB queues with active set to false.
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
943 satb_mq_set.set_active_all_threads(true, /* new active value */
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
944 false /* expected_active */);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
945
4837
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
946 _root_regions.prepare_for_scan();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
947
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
948 // update_g1_committed() will be called at the end of an evac pause
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
949 // when marking is on. So, it's also called at the end of the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
950 // initial-mark pause to update the heap end, if the heap expands
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
951 // during it. No need to call it here.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
952 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
953
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
954 /*
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
955 * Notice that in the next two methods, we actually leave the STS
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
956 * during the barrier sync and join it immediately afterwards. If we
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
957 * do not do this, the following deadlock can occur: one thread could
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
958 * be in the barrier sync code, waiting for the other thread to also
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
959 * sync up, whereas another one could be trying to yield, while also
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
960 * waiting for the other threads to sync up too.
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
961 *
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
962 * Note, however, that this code is also used during remark and in
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
963 * this case we should not attempt to leave / enter the STS, otherwise
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
964 * we'll either hit an asseert (debug / fastdebug) or deadlock
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
965 * (product). So we should only leave / enter the STS if we are
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
966 * operating concurrently.
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
967 *
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
968 * Because the thread that does the sync barrier has left the STS, it
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
969 * is possible to be suspended for a Full GC or an evacuation pause
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
970 * could occur. This is actually safe, since the entering the sync
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
971 * barrier is one of the last things do_marking_step() does, and it
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
972 * doesn't manipulate any data structures afterwards.
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
973 */
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
974
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
975 void ConcurrentMark::enter_first_sync_barrier(uint worker_id) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
976 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
977 gclog_or_tty->print_cr("[%u] entering first barrier", worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
978 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
979
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
980 if (concurrent()) {
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
981 SuspendibleThreadSet::leave();
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
982 }
17949
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
983
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
984 bool barrier_aborted = !_first_overflow_barrier_sync.enter();
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
985
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
986 if (concurrent()) {
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
987 SuspendibleThreadSet::join();
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
988 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
989 // at this point everyone should have synced up and not be doing any
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
990 // more work
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
991
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
992 if (verbose_low()) {
17949
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
993 if (barrier_aborted) {
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
994 gclog_or_tty->print_cr("[%u] aborted first barrier", worker_id);
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
995 } else {
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
996 gclog_or_tty->print_cr("[%u] leaving first barrier", worker_id);
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
997 }
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
998 }
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
999
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1000 if (barrier_aborted) {
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1001 // If the barrier aborted we ignore the overflow condition and
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1002 // just abort the whole marking phase as quickly as possible.
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1003 return;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1004 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1005
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1006 // If we're executing the concurrent phase of marking, reset the marking
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1007 // state; otherwise the marking state is reset after reference processing,
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1008 // during the remark pause.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1009 // If we reset here as a result of an overflow during the remark we will
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1010 // see assertion failures from any subsequent set_concurrency_and_phase()
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1011 // calls.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1012 if (concurrent()) {
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1013 // let the task associated with with worker 0 do this
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1014 if (worker_id == 0) {
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1015 // task 0 is responsible for clearing the global data structures
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1016 // We should be here because of an overflow. During STW we should
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1017 // not clear the overflow flag since we rely on it being true when
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1018 // we exit this method to abort the pause and restart concurent
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1019 // marking.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1020 reset_marking_state(true /* clear_overflow */);
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1021 force_overflow()->update();
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1022
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1023 if (G1Log::fine()) {
20190
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
1024 gclog_or_tty->gclog_stamp(concurrent_gc_id());
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1025 gclog_or_tty->print_cr("[GC concurrent-mark-reset-for-overflow]");
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1026 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1027 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1028 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1029
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1030 // after this, each task should reset its own data structures then
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1031 // then go into the second barrier
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1032 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1033
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
1034 void ConcurrentMark::enter_second_sync_barrier(uint worker_id) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1035 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
1036 gclog_or_tty->print_cr("[%u] entering second barrier", worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1037 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1038
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1039 if (concurrent()) {
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
1040 SuspendibleThreadSet::leave();
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1041 }
17949
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1042
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1043 bool barrier_aborted = !_second_overflow_barrier_sync.enter();
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1044
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1045 if (concurrent()) {
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
1046 SuspendibleThreadSet::join();
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1047 }
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1048 // at this point everything should be re-initialized and ready to go
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1049
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1050 if (verbose_low()) {
17949
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1051 if (barrier_aborted) {
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1052 gclog_or_tty->print_cr("[%u] aborted second barrier", worker_id);
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1053 } else {
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1054 gclog_or_tty->print_cr("[%u] leaving second barrier", worker_id);
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
1055 }
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1056 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1057 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1058
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1059 #ifndef PRODUCT
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1060 void ForceOverflowSettings::init() {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1061 _num_remaining = G1ConcMarkForceOverflow;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1062 _force = false;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1063 update();
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1064 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1065
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1066 void ForceOverflowSettings::update() {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1067 if (_num_remaining > 0) {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1068 _num_remaining -= 1;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1069 _force = true;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1070 } else {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1071 _force = false;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1072 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1073 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1074
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1075 bool ForceOverflowSettings::should_force() {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1076 if (_force) {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1077 _force = false;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1078 return true;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1079 } else {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1080 return false;
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1081 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1082 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1083 #endif // !PRODUCT
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1084
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1085 class CMConcurrentMarkingTask: public AbstractGangTask {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1086 private:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1087 ConcurrentMark* _cm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1088 ConcurrentMarkThread* _cmt;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1089
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1090 public:
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1091 void work(uint worker_id) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
1092 assert(Thread::current()->is_ConcurrentGC_thread(),
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
1093 "this should only be done by a conc GC thread");
1974
fd1d227ef1b9 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 1972
diff changeset
1094 ResourceMark rm;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1095
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1096 double start_vtime = os::elapsedVTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1097
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
1098 SuspendibleThreadSet::join();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1099
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1100 assert(worker_id < _cm->active_tasks(), "invariant");
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1101 CMTask* the_task = _cm->task(worker_id);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1102 the_task->record_start_time();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1103 if (!_cm->has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1104 do {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1105 double start_vtime_sec = os::elapsedVTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1106 double start_time_sec = os::elapsedTime();
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1107 double mark_step_duration_ms = G1ConcMarkStepDurationMillis;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1108
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1109 the_task->do_marking_step(mark_step_duration_ms,
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
1110 true /* do_termination */,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
1111 false /* is_serial*/);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1112
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1113 double end_time_sec = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1114 double end_vtime_sec = os::elapsedVTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1115 double elapsed_vtime_sec = end_vtime_sec - start_vtime_sec;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1116 double elapsed_time_sec = end_time_sec - start_time_sec;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1117 _cm->clear_has_overflown();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1118
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1119 bool ret = _cm->do_yield_check(worker_id);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1120
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1121 jlong sleep_time_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1122 if (!_cm->has_aborted() && the_task->has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1123 sleep_time_ms =
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1124 (jlong) (elapsed_vtime_sec * _cm->sleep_factor() * 1000.0);
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
1125 SuspendibleThreadSet::leave();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1126 os::sleep(Thread::current(), sleep_time_ms, false);
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
1127 SuspendibleThreadSet::join();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1128 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1129 double end_time2_sec = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1130 double elapsed_time2_sec = end_time2_sec - start_time_sec;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1131
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1132 #if 0
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1133 gclog_or_tty->print_cr("CM: elapsed %1.4lf ms, sleep %1.4lf ms, "
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1134 "overhead %1.4lf",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1135 elapsed_vtime_sec * 1000.0, (double) sleep_time_ms,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1136 the_task->conc_overhead(os::elapsedTime()) * 8.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1137 gclog_or_tty->print_cr("elapsed time %1.4lf ms, time 2: %1.4lf ms",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1138 elapsed_time_sec * 1000.0, elapsed_time2_sec * 1000.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1139 #endif
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1140 } while (!_cm->has_aborted() && the_task->has_aborted());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1141 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1142 the_task->record_end_time();
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
1143 guarantee(!the_task->has_aborted() || _cm->has_aborted(), "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1144
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
1145 SuspendibleThreadSet::leave();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1146
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1147 double end_vtime = os::elapsedVTime();
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1148 _cm->update_accum_task_vtime(worker_id, end_vtime - start_vtime);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1149 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1150
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1151 CMConcurrentMarkingTask(ConcurrentMark* cm,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1152 ConcurrentMarkThread* cmt) :
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1153 AbstractGangTask("Concurrent Mark"), _cm(cm), _cmt(cmt) { }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1154
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1155 ~CMConcurrentMarkingTask() { }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1156 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1157
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1158 // Calculates the number of active workers for a concurrent
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1159 // phase.
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1160 uint ConcurrentMark::calc_parallel_marking_threads() {
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1161 if (G1CollectedHeap::use_parallel_gc_threads()) {
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1162 uint n_conc_workers = 0;
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1163 if (!UseDynamicNumberOfGCThreads ||
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1164 (!FLAG_IS_DEFAULT(ConcGCThreads) &&
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1165 !ForceDynamicNumberOfGCThreads)) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1166 n_conc_workers = max_parallel_marking_threads();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1167 } else {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1168 n_conc_workers =
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1169 AdaptiveSizePolicy::calc_default_active_workers(
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1170 max_parallel_marking_threads(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1171 1, /* Minimum workers */
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1172 parallel_marking_threads(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1173 Threads::number_of_non_daemon_threads());
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1174 // Don't scale down "n_conc_workers" by scale_parallel_threads() because
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1175 // that scaling has already gone into "_max_parallel_marking_threads".
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1176 }
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1177 assert(n_conc_workers > 0, "Always need at least 1");
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1178 return n_conc_workers;
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1179 }
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1180 // If we are not running with any parallel GC threads we will not
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1181 // have spawned any marking threads either. Hence the number of
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1182 // concurrent workers should be 0.
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1183 return 0;
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1184 }
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1185
4837
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1186 void ConcurrentMark::scanRootRegion(HeapRegion* hr, uint worker_id) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1187 // Currently, only survivors can be root regions.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1188 assert(hr->next_top_at_mark_start() == hr->bottom(), "invariant");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1189 G1RootRegionScanClosure cl(_g1h, this, worker_id);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1190
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1191 const uintx interval = PrefetchScanIntervalInBytes;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1192 HeapWord* curr = hr->bottom();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1193 const HeapWord* end = hr->top();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1194 while (curr < end) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1195 Prefetch::read(curr, interval);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1196 oop obj = oop(curr);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1197 int size = obj->oop_iterate(&cl);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1198 assert(size == obj->size(), "sanity");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1199 curr += size;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1200 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1201 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1202
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1203 class CMRootRegionScanTask : public AbstractGangTask {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1204 private:
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1205 ConcurrentMark* _cm;
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1206
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1207 public:
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1208 CMRootRegionScanTask(ConcurrentMark* cm) :
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1209 AbstractGangTask("Root Region Scan"), _cm(cm) { }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1210
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1211 void work(uint worker_id) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1212 assert(Thread::current()->is_ConcurrentGC_thread(),
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1213 "this should only be done by a conc GC thread");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1214
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1215 CMRootRegions* root_regions = _cm->root_regions();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1216 HeapRegion* hr = root_regions->claim_next();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1217 while (hr != NULL) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1218 _cm->scanRootRegion(hr, worker_id);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1219 hr = root_regions->claim_next();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1220 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1221 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1222 };
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1223
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1224 void ConcurrentMark::scanRootRegions() {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1225 // scan_in_progress() will have been set to true only if there was
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1226 // at least one root region to scan. So, if it's false, we
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1227 // should not attempt to do any further work.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1228 if (root_regions()->scan_in_progress()) {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1229 _parallel_marking_threads = calc_parallel_marking_threads();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1230 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1231 "Maximum number of marking threads exceeded");
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1232 uint active_workers = MAX2(1U, parallel_marking_threads());
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1233
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1234 CMRootRegionScanTask task(this);
8008
256d3f43c177 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 8006
diff changeset
1235 if (use_parallel_marking_threads()) {
4837
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1236 _parallel_workers->set_active_workers((int) active_workers);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1237 _parallel_workers->run_task(&task);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1238 } else {
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1239 task.work(0);
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1240 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1241
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1242 // It's possible that has_aborted() is true here without actually
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1243 // aborting the survivor scan earlier. This is OK as it's
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1244 // mainly used for sanity checking.
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1245 root_regions()->scan_finished();
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1246 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1247 }
eff609af17d7 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 4836
diff changeset
1248
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1249 void ConcurrentMark::markFromRoots() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1250 // we might be tempted to assert that:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1251 // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1252 // "inconsistent argument?");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1253 // However that wouldn't be right, because it's possible that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1254 // a safepoint is indeed in progress as a younger generation
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1255 // stop-the-world GC happens even as we mark in this generation.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1256
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1257 _restart_for_overflow = false;
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
1258 force_overflow_conc()->init();
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1259
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1260 // _g1h has _n_par_threads
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1261 _parallel_marking_threads = calc_parallel_marking_threads();
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1262 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1263 "Maximum number of marking threads exceeded");
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1264
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1265 uint active_workers = MAX2(1U, parallel_marking_threads());
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1266
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1267 // Parallel task terminator is set in "set_concurrency_and_phase()"
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
1268 set_concurrency_and_phase(active_workers, true /* concurrent */);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1269
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1270 CMConcurrentMarkingTask markingTask(this, cmThread());
8008
256d3f43c177 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 8006
diff changeset
1271 if (use_parallel_marking_threads()) {
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1272 _parallel_workers->set_active_workers((int)active_workers);
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1273 // Don't set _n_par_threads because it affects MT in proceess_strong_roots()
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1274 // and the decisions on that MT processing is made elsewhere.
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
1275 assert(_parallel_workers->active_workers() > 0, "Should have been set");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1276 _parallel_workers->run_task(&markingTask);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1277 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1278 markingTask.work(0);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1279 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1280 print_stats();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1281 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1282
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1283 void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1284 // world is stopped at this checkpoint
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1285 assert(SafepointSynchronize::is_at_safepoint(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1286 "world should be stopped");
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
1287
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1288 G1CollectedHeap* g1h = G1CollectedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1289
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1290 // If a full collection has happened, we shouldn't do this.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1291 if (has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1292 g1h->set_marking_complete(); // So bitmap clearing isn't confused
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1293 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1294 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1295
2125
7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents: 2037
diff changeset
1296 SvcGCMarker sgcm(SvcGCMarker::OTHER);
7246a374a9f2 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents: 2037
diff changeset
1297
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1298 if (VerifyDuringGC) {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1299 HandleMark hm; // handle scope
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1300 Universe::heap()->prepare_for_verify();
10186
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1301 Universe::verify(VerifyOption_G1UsePrevMarking,
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1302 " VerifyDuringGC:(before)");
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1303 }
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1304
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1305 G1CollectorPolicy* g1p = g1h->g1_policy();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1306 g1p->record_concurrent_mark_remark_start();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1307
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1308 double start = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1309
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1310 checkpointRootsFinalWork();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1311
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1312 double mark_work_end = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1313
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1314 weakRefsWork(clear_all_soft_refs);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1315
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1316 if (has_overflown()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1317 // Oops. We overflowed. Restart concurrent marking.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1318 _restart_for_overflow = true;
8789
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1319 if (G1TraceMarkStackOverflow) {
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1320 gclog_or_tty->print_cr("\nRemark led to restart for overflow.");
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1321 }
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1322
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1323 // Verify the heap w.r.t. the previous marking bitmap.
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1324 if (VerifyDuringGC) {
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1325 HandleMark hm; // handle scope
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1326 Universe::heap()->prepare_for_verify();
10186
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1327 Universe::verify(VerifyOption_G1UsePrevMarking,
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1328 " VerifyDuringGC:(overflow)");
8789
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1329 }
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
1330
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
1331 // Clear the marking state because we will be restarting
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
1332 // marking due to overflowing the global mark stack.
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
1333 reset_marking_state();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1334 } else {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1335 // Aggregate the per-task counting data that we have accumulated
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1336 // while marking.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1337 aggregate_count_data();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1338
2149
7e37af9d69ef 7011379: G1: overly long concurrent marking cycles
tonyp
parents: 2125
diff changeset
1339 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1340 // We're done with marking.
1317
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
1341 // This is the end of the marking cycle, we're expected all
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
1342 // threads to have SATB queues with active set to true.
2149
7e37af9d69ef 7011379: G1: overly long concurrent marking cycles
tonyp
parents: 2125
diff changeset
1343 satb_mq_set.set_active_all_threads(false, /* new active value */
7e37af9d69ef 7011379: G1: overly long concurrent marking cycles
tonyp
parents: 2125
diff changeset
1344 true /* expected_active */);
811
830ca2573896 6850846: G1: extend G1 marking verification
tonyp
parents: 751
diff changeset
1345
830ca2573896 6850846: G1: extend G1 marking verification
tonyp
parents: 751
diff changeset
1346 if (VerifyDuringGC) {
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1347 HandleMark hm; // handle scope
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1348 Universe::heap()->prepare_for_verify();
10186
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1349 Universe::verify(VerifyOption_G1UseNextMarking,
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1350 " VerifyDuringGC:(after)");
811
830ca2573896 6850846: G1: extend G1 marking verification
tonyp
parents: 751
diff changeset
1351 }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1352 assert(!restart_for_overflow(), "sanity");
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
1353 // Completely reset the marking state since marking completed
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
1354 set_non_marking_state();
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1355 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
1356
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
1357 // Expand the marking stack, if we have to and if we can.
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
1358 if (_markStack.should_expand()) {
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
1359 _markStack.expand();
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
1360 }
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
1361
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1362 // Statistics
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1363 double now = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1364 _remark_mark_times.add((mark_work_end - start) * 1000.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1365 _remark_weak_ref_times.add((now - mark_work_end) * 1000.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1366 _remark_times.add((now - start) * 1000.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1367
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1368 g1p->record_concurrent_mark_remark_end();
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
1369
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
1370 G1CMIsAliveClosure is_alive(g1h);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
1371 g1h->gc_tracer_cm()->report_object_count_after_gc(&is_alive);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1372 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1373
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1374 // Base class of the closures that finalize and verify the
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1375 // liveness counting data.
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1376 class CMCountDataClosureBase: public HeapRegionClosure {
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1377 protected:
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1378 G1CollectedHeap* _g1h;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1379 ConcurrentMark* _cm;
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1380 CardTableModRefBS* _ct_bs;
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1381
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1382 BitMap* _region_bm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1383 BitMap* _card_bm;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1384
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1385 // Takes a region that's not empty (i.e., it has at least one
829
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1386 // live object in it and sets its corresponding bit on the region
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1387 // bitmap to 1. If the region is "starts humongous" it will also set
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1388 // to 1 the bits on the region bitmap that correspond to its
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1389 // associated "continues humongous" regions.
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1390 void set_bit_for_region(HeapRegion* hr) {
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1391 assert(!hr->continuesHumongous(), "should have filtered those out");
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1392
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1393 BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index();
829
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1394 if (!hr->startsHumongous()) {
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1395 // Normal (non-humongous) case: just set the bit.
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1396 _region_bm->par_at_put(index, true);
829
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1397 } else {
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1398 // Starts humongous case: calculate how many regions are part of
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1399 // this humongous region and then set the bit range.
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1400 BitMap::idx_t end_index = (BitMap::idx_t) hr->last_hc_index();
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1401 _region_bm->par_at_put_range(index, end_index, true);
829
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1402 }
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1403 }
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1404
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1405 public:
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1406 CMCountDataClosureBase(G1CollectedHeap* g1h,
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1407 BitMap* region_bm, BitMap* card_bm):
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1408 _g1h(g1h), _cm(g1h->concurrent_mark()),
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1409 _ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1410 _region_bm(region_bm), _card_bm(card_bm) { }
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1411 };
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1412
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1413 // Closure that calculates the # live objects per region. Used
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1414 // for verification purposes during the cleanup pause.
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1415 class CalcLiveObjectsClosure: public CMCountDataClosureBase {
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1416 CMBitMapRO* _bm;
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1417 size_t _region_marked_bytes;
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1418
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1419 public:
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1420 CalcLiveObjectsClosure(CMBitMapRO *bm, G1CollectedHeap* g1h,
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1421 BitMap* region_bm, BitMap* card_bm) :
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1422 CMCountDataClosureBase(g1h, region_bm, card_bm),
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1423 _bm(bm), _region_marked_bytes(0) { }
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1424
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1425 bool doHeapRegion(HeapRegion* hr) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1426
639
922c573ea67d 6815683: G1: SEGV during marking
iveresov
parents: 619
diff changeset
1427 if (hr->continuesHumongous()) {
829
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1428 // We will ignore these here and process them when their
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1429 // associated "starts humongous" region is processed (see
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1430 // set_bit_for_heap_region()). Note that we cannot rely on their
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1431 // associated "starts humongous" region to have their bit set to
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1432 // 1 since, due to the region chunking in the parallel region
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1433 // iteration, a "continues humongous" region might be visited
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1434 // before its associated "starts humongous".
639
922c573ea67d 6815683: G1: SEGV during marking
iveresov
parents: 619
diff changeset
1435 return false;
922c573ea67d 6815683: G1: SEGV during marking
iveresov
parents: 619
diff changeset
1436 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1437
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1438 HeapWord* ntams = hr->next_top_at_mark_start();
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1439 HeapWord* start = hr->bottom();
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1440
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1441 assert(start <= hr->end() && start <= ntams && ntams <= hr->end(),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1442 err_msg("Preconditions not met - "
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1443 "start: "PTR_FORMAT", ntams: "PTR_FORMAT", end: "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
1444 p2i(start), p2i(ntams), p2i(hr->end())));
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1445
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1446 // Find the first marked object at or after "start".
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1447 start = _bm->getNextMarkedWordAddress(start, ntams);
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1448
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1449 size_t marked_bytes = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1450
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1451 while (start < ntams) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1452 oop obj = oop(start);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1453 int obj_sz = obj->size();
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1454 HeapWord* obj_end = start + obj_sz;
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1455
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1456 BitMap::idx_t start_idx = _cm->card_bitmap_index_for(start);
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1457 BitMap::idx_t end_idx = _cm->card_bitmap_index_for(obj_end);
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1458
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1459 // Note: if we're looking at the last region in heap - obj_end
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1460 // could be actually just beyond the end of the heap; end_idx
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1461 // will then correspond to a (non-existent) card that is also
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1462 // just beyond the heap.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1463 if (_g1h->is_in_g1_reserved(obj_end) && !_ct_bs->is_card_aligned(obj_end)) {
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1464 // end of object is not card aligned - increment to cover
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1465 // all the cards spanned by the object
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1466 end_idx += 1;
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1467 }
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1468
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1469 // Set the bits in the card BM for the cards spanned by this object.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1470 _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1471
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1472 // Add the size of this object to the number of marked bytes.
1030
dfdaf65c3423 6858886: G1: guarantee(_next_marked_bytes <= used(),"invariant") at heapRegion.hpp:359
apetrusenko
parents: 1023
diff changeset
1473 marked_bytes += (size_t)obj_sz * HeapWordSize;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1474
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1475 // Find the next marked object after this one.
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1476 start = _bm->getNextMarkedWordAddress(obj_end, ntams);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1477 }
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1478
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1479 // Mark the allocated-since-marking portion...
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1480 HeapWord* top = hr->top();
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1481 if (ntams < top) {
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1482 BitMap::idx_t start_idx = _cm->card_bitmap_index_for(ntams);
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1483 BitMap::idx_t end_idx = _cm->card_bitmap_index_for(top);
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1484
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1485 // Note: if we're looking at the last region in heap - top
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1486 // could be actually just beyond the end of the heap; end_idx
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1487 // will then correspond to a (non-existent) card that is also
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1488 // just beyond the heap.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1489 if (_g1h->is_in_g1_reserved(top) && !_ct_bs->is_card_aligned(top)) {
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1490 // end of object is not card aligned - increment to cover
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1491 // all the cards spanned by the object
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1492 end_idx += 1;
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1493 }
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1494 _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1495
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1496 // This definitely means the region has live objects.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1497 set_bit_for_region(hr);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1498 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1499
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1500 // Update the live region bitmap.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1501 if (marked_bytes > 0) {
829
30b9b25b9cc1 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 811
diff changeset
1502 set_bit_for_region(hr);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1503 }
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1504
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1505 // Set the marked bytes for the current region so that
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1506 // it can be queried by a calling verificiation routine
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1507 _region_marked_bytes = marked_bytes;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1508
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1509 return false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1510 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1511
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1512 size_t region_marked_bytes() const { return _region_marked_bytes; }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1513 };
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1514
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1515 // Heap region closure used for verifying the counting data
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1516 // that was accumulated concurrently and aggregated during
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1517 // the remark pause. This closure is applied to the heap
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1518 // regions during the STW cleanup pause.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1519
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1520 class VerifyLiveObjectDataHRClosure: public HeapRegionClosure {
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1521 G1CollectedHeap* _g1h;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1522 ConcurrentMark* _cm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1523 CalcLiveObjectsClosure _calc_cl;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1524 BitMap* _region_bm; // Region BM to be verified
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1525 BitMap* _card_bm; // Card BM to be verified
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1526 bool _verbose; // verbose output?
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1527
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1528 BitMap* _exp_region_bm; // Expected Region BM values
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1529 BitMap* _exp_card_bm; // Expected card BM values
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1530
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1531 int _failures;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1532
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1533 public:
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1534 VerifyLiveObjectDataHRClosure(G1CollectedHeap* g1h,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1535 BitMap* region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1536 BitMap* card_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1537 BitMap* exp_region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1538 BitMap* exp_card_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1539 bool verbose) :
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1540 _g1h(g1h), _cm(g1h->concurrent_mark()),
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1541 _calc_cl(_cm->nextMarkBitMap(), g1h, exp_region_bm, exp_card_bm),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1542 _region_bm(region_bm), _card_bm(card_bm), _verbose(verbose),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1543 _exp_region_bm(exp_region_bm), _exp_card_bm(exp_card_bm),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1544 _failures(0) { }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1545
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1546 int failures() const { return _failures; }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1547
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1548 bool doHeapRegion(HeapRegion* hr) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1549 if (hr->continuesHumongous()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1550 // We will ignore these here and process them when their
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1551 // associated "starts humongous" region is processed (see
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1552 // set_bit_for_heap_region()). Note that we cannot rely on their
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1553 // associated "starts humongous" region to have their bit set to
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1554 // 1 since, due to the region chunking in the parallel region
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1555 // iteration, a "continues humongous" region might be visited
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1556 // before its associated "starts humongous".
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1557 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1558 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1559
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1560 int failures = 0;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1561
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1562 // Call the CalcLiveObjectsClosure to walk the marking bitmap for
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1563 // this region and set the corresponding bits in the expected region
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1564 // and card bitmaps.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1565 bool res = _calc_cl.doHeapRegion(hr);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1566 assert(res == false, "should be continuing");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1567
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1568 MutexLockerEx x((_verbose ? ParGCRareEvent_lock : NULL),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1569 Mutex::_no_safepoint_check_flag);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1570
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1571 // Verify the marked bytes for this region.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1572 size_t exp_marked_bytes = _calc_cl.region_marked_bytes();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1573 size_t act_marked_bytes = hr->next_marked_bytes();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1574
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1575 // We're not OK if expected marked bytes > actual marked bytes. It means
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1576 // we have missed accounting some objects during the actual marking.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1577 if (exp_marked_bytes > act_marked_bytes) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1578 if (_verbose) {
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1579 gclog_or_tty->print_cr("Region %u: marked bytes mismatch: "
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1580 "expected: " SIZE_FORMAT ", actual: " SIZE_FORMAT,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1581 hr->hrs_index(), exp_marked_bytes, act_marked_bytes);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1582 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1583 failures += 1;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1584 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1585
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1586 // Verify the bit, for this region, in the actual and expected
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1587 // (which was just calculated) region bit maps.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1588 // We're not OK if the bit in the calculated expected region
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1589 // bitmap is set and the bit in the actual region bitmap is not.
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1590 BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index();
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1591
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1592 bool expected = _exp_region_bm->at(index);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1593 bool actual = _region_bm->at(index);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1594 if (expected && !actual) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1595 if (_verbose) {
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1596 gclog_or_tty->print_cr("Region %u: region bitmap mismatch: "
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1597 "expected: %s, actual: %s",
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1598 hr->hrs_index(),
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1599 BOOL_TO_STR(expected), BOOL_TO_STR(actual));
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1600 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1601 failures += 1;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1602 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1603
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1604 // Verify that the card bit maps for the cards spanned by the current
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1605 // region match. We have an error if we have a set bit in the expected
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1606 // bit map and the corresponding bit in the actual bitmap is not set.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1607
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1608 BitMap::idx_t start_idx = _cm->card_bitmap_index_for(hr->bottom());
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1609 BitMap::idx_t end_idx = _cm->card_bitmap_index_for(hr->top());
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1610
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1611 for (BitMap::idx_t i = start_idx; i < end_idx; i+=1) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1612 expected = _exp_card_bm->at(i);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1613 actual = _card_bm->at(i);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1614
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1615 if (expected && !actual) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1616 if (_verbose) {
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1617 gclog_or_tty->print_cr("Region %u: card bitmap mismatch at " SIZE_FORMAT ": "
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1618 "expected: %s, actual: %s",
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1619 hr->hrs_index(), i,
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1620 BOOL_TO_STR(expected), BOOL_TO_STR(actual));
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1621 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1622 failures += 1;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1623 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1624 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1625
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1626 if (failures > 0 && _verbose) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1627 gclog_or_tty->print_cr("Region " HR_FORMAT ", ntams: " PTR_FORMAT ", "
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1628 "marked_bytes: calc/actual " SIZE_FORMAT "/" SIZE_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
1629 HR_FORMAT_PARAMS(hr), p2i(hr->next_top_at_mark_start()),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1630 _calc_cl.region_marked_bytes(), hr->next_marked_bytes());
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1631 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1632
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1633 _failures += failures;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1634
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1635 // We could stop iteration over the heap when we
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1636 // find the first violating region by returning true.
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1637 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1638 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1639 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1640
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1641 class G1ParVerifyFinalCountTask: public AbstractGangTask {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1642 protected:
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1643 G1CollectedHeap* _g1h;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1644 ConcurrentMark* _cm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1645 BitMap* _actual_region_bm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1646 BitMap* _actual_card_bm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1647
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1648 uint _n_workers;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1649
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1650 BitMap* _expected_region_bm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1651 BitMap* _expected_card_bm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1652
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1653 int _failures;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1654 bool _verbose;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1655
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1656 public:
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1657 G1ParVerifyFinalCountTask(G1CollectedHeap* g1h,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1658 BitMap* region_bm, BitMap* card_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1659 BitMap* expected_region_bm, BitMap* expected_card_bm)
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1660 : AbstractGangTask("G1 verify final counting"),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1661 _g1h(g1h), _cm(_g1h->concurrent_mark()),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1662 _actual_region_bm(region_bm), _actual_card_bm(card_bm),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1663 _expected_region_bm(expected_region_bm), _expected_card_bm(expected_card_bm),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1664 _failures(0), _verbose(false),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1665 _n_workers(0) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1666 assert(VerifyDuringGC, "don't call this otherwise");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1667
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1668 // Use the value already set as the number of active threads
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1669 // in the call to run_task().
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1670 if (G1CollectedHeap::use_parallel_gc_threads()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1671 assert( _g1h->workers()->active_workers() > 0,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1672 "Should have been previously set");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1673 _n_workers = _g1h->workers()->active_workers();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1674 } else {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1675 _n_workers = 1;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1676 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1677
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1678 assert(_expected_card_bm->size() == _actual_card_bm->size(), "sanity");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1679 assert(_expected_region_bm->size() == _actual_region_bm->size(), "sanity");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1680
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1681 _verbose = _cm->verbose_medium();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1682 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1683
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1684 void work(uint worker_id) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1685 assert(worker_id < _n_workers, "invariant");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1686
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1687 VerifyLiveObjectDataHRClosure verify_cl(_g1h,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1688 _actual_region_bm, _actual_card_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1689 _expected_region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1690 _expected_card_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1691 _verbose);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1692
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1693 if (G1CollectedHeap::use_parallel_gc_threads()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1694 _g1h->heap_region_par_iterate_chunked(&verify_cl,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1695 worker_id,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1696 _n_workers,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1697 HeapRegion::VerifyCountClaimValue);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1698 } else {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1699 _g1h->heap_region_iterate(&verify_cl);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1700 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1701
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1702 Atomic::add(verify_cl.failures(), &_failures);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1703 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1704
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1705 int failures() const { return _failures; }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1706 };
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1707
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1708 // Closure that finalizes the liveness counting data.
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1709 // Used during the cleanup pause.
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1710 // Sets the bits corresponding to the interval [NTAMS, top]
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1711 // (which contains the implicitly live objects) in the
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1712 // card liveness bitmap. Also sets the bit for each region,
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1713 // containing live data, in the region liveness bitmap.
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1714
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1715 class FinalCountDataUpdateClosure: public CMCountDataClosureBase {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1716 public:
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1717 FinalCountDataUpdateClosure(G1CollectedHeap* g1h,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1718 BitMap* region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1719 BitMap* card_bm) :
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1720 CMCountDataClosureBase(g1h, region_bm, card_bm) { }
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1721
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1722 bool doHeapRegion(HeapRegion* hr) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1723
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1724 if (hr->continuesHumongous()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1725 // We will ignore these here and process them when their
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1726 // associated "starts humongous" region is processed (see
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1727 // set_bit_for_heap_region()). Note that we cannot rely on their
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1728 // associated "starts humongous" region to have their bit set to
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1729 // 1 since, due to the region chunking in the parallel region
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1730 // iteration, a "continues humongous" region might be visited
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1731 // before its associated "starts humongous".
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1732 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1733 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1734
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1735 HeapWord* ntams = hr->next_top_at_mark_start();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1736 HeapWord* top = hr->top();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1737
6027
8a2e5a6a19a4 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 6011
diff changeset
1738 assert(hr->bottom() <= ntams && ntams <= hr->end(), "Preconditions.");
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1739
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1740 // Mark the allocated-since-marking portion...
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1741 if (ntams < top) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1742 // This definitely means the region has live objects.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1743 set_bit_for_region(hr);
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1744
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1745 // Now set the bits in the card bitmap for [ntams, top)
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1746 BitMap::idx_t start_idx = _cm->card_bitmap_index_for(ntams);
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1747 BitMap::idx_t end_idx = _cm->card_bitmap_index_for(top);
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1748
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1749 // Note: if we're looking at the last region in heap - top
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1750 // could be actually just beyond the end of the heap; end_idx
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1751 // will then correspond to a (non-existent) card that is also
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1752 // just beyond the heap.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1753 if (_g1h->is_in_g1_reserved(top) && !_ct_bs->is_card_aligned(top)) {
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1754 // end of object is not card aligned - increment to cover
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1755 // all the cards spanned by the object
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1756 end_idx += 1;
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1757 }
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1758
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1759 assert(end_idx <= _card_bm->size(),
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1760 err_msg("oob: end_idx= "SIZE_FORMAT", bitmap size= "SIZE_FORMAT,
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1761 end_idx, _card_bm->size()));
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1762 assert(start_idx < _card_bm->size(),
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1763 err_msg("oob: start_idx= "SIZE_FORMAT", bitmap size= "SIZE_FORMAT,
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1764 start_idx, _card_bm->size()));
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1765
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1766 _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6254
diff changeset
1767 }
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1768
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1769 // Set the bit for the region if it contains live data
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1770 if (hr->next_marked_bytes() > 0) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1771 set_bit_for_region(hr);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1772 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1773
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1774 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1775 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1776 };
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1777
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1778 class G1ParFinalCountTask: public AbstractGangTask {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1779 protected:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1780 G1CollectedHeap* _g1h;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1781 ConcurrentMark* _cm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1782 BitMap* _actual_region_bm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1783 BitMap* _actual_card_bm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1784
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1785 uint _n_workers;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1786
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1787 public:
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1788 G1ParFinalCountTask(G1CollectedHeap* g1h, BitMap* region_bm, BitMap* card_bm)
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1789 : AbstractGangTask("G1 final counting"),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1790 _g1h(g1h), _cm(_g1h->concurrent_mark()),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1791 _actual_region_bm(region_bm), _actual_card_bm(card_bm),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1792 _n_workers(0) {
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1793 // Use the value already set as the number of active threads
6011
f7a8920427a6 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 6010
diff changeset
1794 // in the call to run_task().
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1795 if (G1CollectedHeap::use_parallel_gc_threads()) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1796 assert( _g1h->workers()->active_workers() > 0,
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1797 "Should have been previously set");
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1798 _n_workers = _g1h->workers()->active_workers();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1799 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1800 _n_workers = 1;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
1801 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1802 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1803
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1804 void work(uint worker_id) {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1805 assert(worker_id < _n_workers, "invariant");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1806
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
1807 FinalCountDataUpdateClosure final_update_cl(_g1h,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1808 _actual_region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1809 _actual_card_bm);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1810
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
1811 if (G1CollectedHeap::use_parallel_gc_threads()) {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1812 _g1h->heap_region_par_iterate_chunked(&final_update_cl,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1813 worker_id,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1814 _n_workers,
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
1815 HeapRegion::FinalCountClaimValue);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1816 } else {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1817 _g1h->heap_region_iterate(&final_update_cl);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1818 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1819 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1820 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1821
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1822 class G1ParNoteEndTask;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1823
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1824 class G1NoteEndOfConcMarkClosure : public HeapRegionClosure {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1825 G1CollectedHeap* _g1;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1826 size_t _max_live_bytes;
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1827 uint _regions_claimed;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1828 size_t _freed_bytes;
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1829 FreeRegionList* _local_cleanup_list;
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1830 HeapRegionSetCount _old_regions_removed;
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1831 HeapRegionSetCount _humongous_regions_removed;
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1832 HRRSCleanupTask* _hrrs_cleanup_task;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1833 double _claimed_region_time;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1834 double _max_region_time;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1835
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1836 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1837 G1NoteEndOfConcMarkClosure(G1CollectedHeap* g1,
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1838 FreeRegionList* local_cleanup_list,
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1839 HRRSCleanupTask* hrrs_cleanup_task) :
17844
8847586c9037 8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents: 17841
diff changeset
1840 _g1(g1),
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1841 _max_live_bytes(0), _regions_claimed(0),
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1842 _freed_bytes(0),
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1843 _claimed_region_time(0.0), _max_region_time(0.0),
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1844 _local_cleanup_list(local_cleanup_list),
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1845 _old_regions_removed(),
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1846 _humongous_regions_removed(),
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1847 _hrrs_cleanup_task(hrrs_cleanup_task) { }
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1848
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1849 size_t freed_bytes() { return _freed_bytes; }
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1850 const HeapRegionSetCount& old_regions_removed() { return _old_regions_removed; }
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1851 const HeapRegionSetCount& humongous_regions_removed() { return _humongous_regions_removed; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1852
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1853 bool doHeapRegion(HeapRegion *hr) {
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1854 if (hr->continuesHumongous()) {
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1855 return false;
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1856 }
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1857 // We use a claim value of zero here because all regions
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1858 // were claimed with value 1 in the FinalCount task.
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1859 _g1->reset_gc_time_stamps(hr);
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1860 double start = os::elapsedTime();
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1861 _regions_claimed++;
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1862 hr->note_end_of_marking();
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1863 _max_live_bytes += hr->max_live_bytes();
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1864
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1865 if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) {
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1866 _freed_bytes += hr->used();
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1867 hr->set_containing_set(NULL);
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1868 if (hr->isHumongous()) {
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1869 assert(hr->startsHumongous(), "we should only see starts humongous");
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1870 _humongous_regions_removed.increment(1u, hr->capacity());
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1871 _g1->free_humongous_region(hr, _local_cleanup_list, true);
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1872 } else {
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1873 _old_regions_removed.increment(1u, hr->capacity());
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1874 _g1->free_region(hr, _local_cleanup_list, true);
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1875 }
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1876 } else {
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1877 hr->rem_set()->do_cleanup_work(_hrrs_cleanup_task);
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1878 }
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1879
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1880 double region_time = (os::elapsedTime() - start);
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1881 _claimed_region_time += region_time;
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1882 if (region_time > _max_region_time) {
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
1883 _max_region_time = region_time;
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1884 }
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1885 return false;
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
1886 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1887
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1888 size_t max_live_bytes() { return _max_live_bytes; }
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
1889 uint regions_claimed() { return _regions_claimed; }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1890 double claimed_region_time_sec() { return _claimed_region_time; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1891 double max_region_time_sec() { return _max_region_time; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1892 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1893
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1894 class G1ParNoteEndTask: public AbstractGangTask {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1895 friend class G1NoteEndOfConcMarkClosure;
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1896
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1897 protected:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1898 G1CollectedHeap* _g1h;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1899 size_t _max_live_bytes;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1900 size_t _freed_bytes;
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1901 FreeRegionList* _cleanup_list;
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1902
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1903 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1904 G1ParNoteEndTask(G1CollectedHeap* g1h,
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1905 FreeRegionList* cleanup_list) :
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1906 AbstractGangTask("G1 note end"), _g1h(g1h),
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1907 _max_live_bytes(0), _freed_bytes(0), _cleanup_list(cleanup_list) { }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1908
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1909 void work(uint worker_id) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1910 double start = os::elapsedTime();
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1911 FreeRegionList local_cleanup_list("Local Cleanup List");
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1912 HRRSCleanupTask hrrs_cleanup_task;
17844
8847586c9037 8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents: 17841
diff changeset
1913 G1NoteEndOfConcMarkClosure g1_note_end(_g1h, &local_cleanup_list,
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1914 &hrrs_cleanup_task);
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
1915 if (G1CollectedHeap::use_parallel_gc_threads()) {
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1916 _g1h->heap_region_par_iterate_chunked(&g1_note_end, worker_id,
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
1917 _g1h->workers()->active_workers(),
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
1918 HeapRegion::NoteEndClaimValue);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1919 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1920 _g1h->heap_region_iterate(&g1_note_end);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1921 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1922 assert(g1_note_end.complete(), "Shouldn't have yielded!");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1923
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1924 // Now update the lists
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1925 _g1h->remove_from_old_sets(g1_note_end.old_regions_removed(), g1_note_end.humongous_regions_removed());
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1926 {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1927 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1928 _g1h->decrement_summary_bytes(g1_note_end.freed_bytes());
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1929 _max_live_bytes += g1_note_end.max_live_bytes();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1930 _freed_bytes += g1_note_end.freed_bytes();
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1931
3778
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1932 // If we iterate over the global cleanup list at the end of
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1933 // cleanup to do this printing we will not guarantee to only
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1934 // generate output for the newly-reclaimed regions (the list
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1935 // might not be empty at the beginning of cleanup; we might
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1936 // still be working on its previous contents). So we do the
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1937 // printing here, before we append the new regions to the global
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1938 // cleanup list.
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1939
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1940 G1HRPrinter* hr_printer = _g1h->hr_printer();
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1941 if (hr_printer->is_active()) {
17736
58fc1b1523dc 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 17635
diff changeset
1942 FreeRegionListIterator iter(&local_cleanup_list);
3778
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1943 while (iter.more_available()) {
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1944 HeapRegion* hr = iter.get_next();
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1945 hr_printer->cleanup(hr);
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1946 }
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1947 }
5f6f2615433a 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 3776
diff changeset
1948
17773
8ee855b4e667 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 17750
diff changeset
1949 _cleanup_list->add_ordered(&local_cleanup_list);
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1950 assert(local_cleanup_list.is_empty(), "post-condition");
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1951
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
1952 HeapRegionRemSet::finish_cleanup_task(&hrrs_cleanup_task);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1953 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1954 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1955 size_t max_live_bytes() { return _max_live_bytes; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1956 size_t freed_bytes() { return _freed_bytes; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1957 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1958
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1959 class G1ParScrubRemSetTask: public AbstractGangTask {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1960 protected:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1961 G1RemSet* _g1rs;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1962 BitMap* _region_bm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1963 BitMap* _card_bm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1964 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1965 G1ParScrubRemSetTask(G1CollectedHeap* g1h,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1966 BitMap* region_bm, BitMap* card_bm) :
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1967 AbstractGangTask("G1 ScrubRS"), _g1rs(g1h->g1_rem_set()),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
1968 _region_bm(region_bm), _card_bm(card_bm) { }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1969
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1970 void work(uint worker_id) {
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
1971 if (G1CollectedHeap::use_parallel_gc_threads()) {
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
1972 _g1rs->scrub_par(_region_bm, _card_bm, worker_id,
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
1973 HeapRegion::ScrubRemSetClaimValue);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1974 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1975 _g1rs->scrub(_region_bm, _card_bm);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1976 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1977 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1978
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1979 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1980
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1981 void ConcurrentMark::cleanup() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1982 // world is stopped at this checkpoint
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1983 assert(SafepointSynchronize::is_at_safepoint(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1984 "world should be stopped");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1985 G1CollectedHeap* g1h = G1CollectedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1986
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1987 // If a full collection has happened, we shouldn't do this.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1988 if (has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1989 g1h->set_marking_complete(); // So bitmap clearing isn't confused
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1990 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1991 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
1992
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1993 g1h->verify_region_sets_optional();
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
1994
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1995 if (VerifyDuringGC) {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1996 HandleMark hm; // handle scope
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
1997 Universe::heap()->prepare_for_verify();
10186
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1998 Universe::verify(VerifyOption_G1UsePrevMarking,
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
1999 " VerifyDuringGC:(before)");
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2000 }
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2001
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2002 G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2003 g1p->record_concurrent_mark_cleanup_start();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2004
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2005 double start = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2006
2173
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
2007 HeapRegionRemSet::reset_for_cleanup_tasks();
97ba643ea3ed 7014261: G1: RSet-related failures
tonyp
parents: 2152
diff changeset
2008
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2009 uint n_workers;
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2010
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2011 // Do counting once more with the world stopped for good measure.
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2012 G1ParFinalCountTask g1_par_count_task(g1h, &_region_bm, &_card_bm);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2013
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
2014 if (G1CollectedHeap::use_parallel_gc_threads()) {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2015 assert(g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2016 "sanity check");
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2017
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
2018 g1h->set_par_threads();
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
2019 n_workers = g1h->n_par_threads();
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2020 assert(g1h->n_par_threads() == n_workers,
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
2021 "Should not have been reset");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2022 g1h->workers()->run_task(&g1_par_count_task);
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2023 // Done with the parallel phase so reset to 0.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2024 g1h->set_par_threads(0);
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2025
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2026 assert(g1h->check_heap_region_claim_values(HeapRegion::FinalCountClaimValue),
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2027 "sanity check");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2028 } else {
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
2029 n_workers = 1;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2030 g1_par_count_task.work(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2031 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2032
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2033 if (VerifyDuringGC) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2034 // Verify that the counting data accumulated during marking matches
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2035 // that calculated by walking the marking bitmap.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2036
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2037 // Bitmaps to hold expected values
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2038 BitMap expected_region_bm(_region_bm.size(), false);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2039 BitMap expected_card_bm(_card_bm.size(), false);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2040
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2041 G1ParVerifyFinalCountTask g1_par_verify_task(g1h,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2042 &_region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2043 &_card_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2044 &expected_region_bm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2045 &expected_card_bm);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2046
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2047 if (G1CollectedHeap::use_parallel_gc_threads()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2048 g1h->set_par_threads((int)n_workers);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2049 g1h->workers()->run_task(&g1_par_verify_task);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2050 // Done with the parallel phase so reset to 0.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2051 g1h->set_par_threads(0);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2052
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2053 assert(g1h->check_heap_region_claim_values(HeapRegion::VerifyCountClaimValue),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2054 "sanity check");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2055 } else {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2056 g1_par_verify_task.work(0);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2057 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2058
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2059 guarantee(g1_par_verify_task.failures() == 0, "Unexpected accounting failures");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2060 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
2061
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2062 size_t start_used_bytes = g1h->used();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2063 g1h->set_marking_complete();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2064
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2065 double count_end = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2066 double this_final_counting_time = (count_end - start);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2067 _total_counting_time += this_final_counting_time;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2068
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
2069 if (G1PrintRegionLivenessInfo) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
2070 G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Marking");
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
2071 _g1h->heap_region_iterate(&cl);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
2072 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
2073
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2074 // Install newly created mark bitMap as "prev".
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2075 swapMarkBitMaps();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2076
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2077 g1h->reset_gc_time_stamp();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2078
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2079 // Note end of marking in all heap regions.
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2080 G1ParNoteEndTask g1_par_note_end_task(g1h, &_cleanup_list);
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
2081 if (G1CollectedHeap::use_parallel_gc_threads()) {
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2082 g1h->set_par_threads((int)n_workers);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2083 g1h->workers()->run_task(&g1_par_note_end_task);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2084 g1h->set_par_threads(0);
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2085
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2086 assert(g1h->check_heap_region_claim_values(HeapRegion::NoteEndClaimValue),
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2087 "sanity check");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2088 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2089 g1_par_note_end_task.work(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2090 }
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2091 g1h->check_gc_time_stamps();
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2092
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2093 if (!cleanup_list_is_empty()) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2094 // The cleanup list is not empty, so we'll have to process it
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2095 // concurrently. Notify anyone else that might be wanting free
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2096 // regions that there will be more free regions coming soon.
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2097 g1h->set_free_regions_coming();
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2098 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2099
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2100 // call below, since it affects the metric by which we sort the heap
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2101 // regions.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2102 if (G1ScrubRemSets) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2103 double rs_scrub_start = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2104 G1ParScrubRemSetTask g1_par_scrub_rs_task(g1h, &_region_bm, &_card_bm);
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
2105 if (G1CollectedHeap::use_parallel_gc_threads()) {
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2106 g1h->set_par_threads((int)n_workers);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2107 g1h->workers()->run_task(&g1_par_scrub_rs_task);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2108 g1h->set_par_threads(0);
355
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2109
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2110 assert(g1h->check_heap_region_claim_values(
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2111 HeapRegion::ScrubRemSetClaimValue),
0edda524b58c 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 343
diff changeset
2112 "sanity check");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2113 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2114 g1_par_scrub_rs_task.work(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2115 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2116
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2117 double rs_scrub_end = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2118 double this_rs_scrub_time = (rs_scrub_end - rs_scrub_start);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2119 _total_rs_scrub_time += this_rs_scrub_time;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2120 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2121
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2122 // this will also free any regions totally full of garbage objects,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2123 // and sort the regions.
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2124 g1h->g1_policy()->record_concurrent_mark_cleanup_end((int)n_workers);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2125
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2126 // Statistics.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2127 double end = os::elapsedTime();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2128 _cleanup_times.add((end - start) * 1000.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2129
6007
5c86f8211d1e 7160728: Introduce an extra logging level for G1 logging
brutisso
parents: 5988
diff changeset
2130 if (G1Log::fine()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2131 g1h->print_size_transition(gclog_or_tty,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2132 start_used_bytes,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2133 g1h->used(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2134 g1h->capacity());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2135 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2136
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2137 // Clean up will have freed any regions completely full of garbage.
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2138 // Update the soft reference policy with the new heap occupancy.
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2139 Universe::update_heap_info_at_gc();
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2140
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2141 // We need to make this be a "collection" so any collection pause that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2142 // races with it goes around and waits for completeCleanup to finish.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2143 g1h->increment_total_collections();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2144
4830
0b3d1ec6eaee 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 4828
diff changeset
2145 // We reclaimed old regions so we should calculate the sizes to make
0b3d1ec6eaee 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 4828
diff changeset
2146 // sure we update the old gen/space data.
0b3d1ec6eaee 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 4828
diff changeset
2147 g1h->g1mm()->update_sizes();
0b3d1ec6eaee 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 4828
diff changeset
2148
751
20c6f43950b5 6490395: G1: Tidy up command line flags.
johnc
parents: 647
diff changeset
2149 if (VerifyDuringGC) {
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2150 HandleMark hm; // handle scope
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2151 Universe::heap()->prepare_for_verify();
10186
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
2152 Universe::verify(VerifyOption_G1UsePrevMarking,
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 9076
diff changeset
2153 " VerifyDuringGC:(after)");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2154 }
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2155
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2156 g1h->verify_region_sets_optional();
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2157 g1h->trace_heap_after_concurrent_cycle();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2158 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2159
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2160 void ConcurrentMark::completeCleanup() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2161 if (has_aborted()) return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2162
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2163 G1CollectedHeap* g1h = G1CollectedHeap::heap();
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2164
17841
14bd75c9dbfa 8039089: List verification enabled in product builds
jwilhelm
parents: 17773
diff changeset
2165 _cleanup_list.verify_optional();
2361
1216415d8e35 7014923: G1: code cleanup
tonyp
parents: 2177
diff changeset
2166 FreeRegionList tmp_free_list("Tmp Free List");
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2167
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2168 if (G1ConcRegionFreeingVerbose) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2169 gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : "
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
2170 "cleanup list has %u entries",
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2171 _cleanup_list.length());
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2172 }
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2173
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2174 // Noone else should be accessing the _cleanup_list at this point,
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2175 // so it's not necessary to take any locks
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2176 while (!_cleanup_list.is_empty()) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2177 HeapRegion* hr = _cleanup_list.remove_head();
17773
8ee855b4e667 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 17750
diff changeset
2178 assert(hr != NULL, "Got NULL from a non-empty list");
3317
063382f9b575 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 3316
diff changeset
2179 hr->par_clear();
17773
8ee855b4e667 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 17750
diff changeset
2180 tmp_free_list.add_ordered(hr);
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2181
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2182 // Instead of adding one region at a time to the secondary_free_list,
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2183 // we accumulate them in the local list and move them a few at a
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2184 // time. This also cuts down on the number of notify_all() calls
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2185 // we do during this process. We'll also append the local list when
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2186 // _cleanup_list is empty (which means we just removed the last
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2187 // region from the _cleanup_list).
2361
1216415d8e35 7014923: G1: code cleanup
tonyp
parents: 2177
diff changeset
2188 if ((tmp_free_list.length() % G1SecondaryFreeListAppendLength == 0) ||
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2189 _cleanup_list.is_empty()) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2190 if (G1ConcRegionFreeingVerbose) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2191 gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : "
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
2192 "appending %u entries to the secondary_free_list, "
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
2193 "cleanup list still has %u entries",
2361
1216415d8e35 7014923: G1: code cleanup
tonyp
parents: 2177
diff changeset
2194 tmp_free_list.length(),
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2195 _cleanup_list.length());
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2196 }
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2197
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2198 {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2199 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
17773
8ee855b4e667 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 17750
diff changeset
2200 g1h->secondary_free_list_add(&tmp_free_list);
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2201 SecondaryFreeList_lock->notify_all();
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2202 }
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2203
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2204 if (G1StressConcRegionFreeing) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2205 for (uintx i = 0; i < G1StressConcRegionFreeingDelayMillis; ++i) {
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2206 os::sleep(Thread::current(), (jlong) 1, false);
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2207 }
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
2208 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2209 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2210 }
2361
1216415d8e35 7014923: G1: code cleanup
tonyp
parents: 2177
diff changeset
2211 assert(tmp_free_list.is_empty(), "post-condition");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2212 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2213
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2214 // Supporting Object and Oop closures for reference discovery
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2215 // and processing in during marking
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2216
2037
b03260081e9b 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 1974
diff changeset
2217 bool G1CMIsAliveClosure::do_object_b(oop obj) {
b03260081e9b 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 1974
diff changeset
2218 HeapWord* addr = (HeapWord*)obj;
b03260081e9b 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 1974
diff changeset
2219 return addr != NULL &&
b03260081e9b 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 1974
diff changeset
2220 (!_g1->is_in_g1_reserved(addr) || !_g1->is_obj_ill(obj));
b03260081e9b 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 1974
diff changeset
2221 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2222
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2223 // 'Keep Alive' oop closure used by both serial parallel reference processing.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2224 // Uses the CMTask associated with a worker thread (for serial reference
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2225 // processing the CMTask for worker 0 is used) to preserve (mark) and
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2226 // trace referent objects.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2227 //
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2228 // Using the CMTask and embedded local queues avoids having the worker
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2229 // threads operating on the global mark stack. This reduces the risk
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2230 // of overflowing the stack - which we would rather avoid at this late
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2231 // state. Also using the tasks' local queues removes the potential
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2232 // of the workers interfering with each other that could occur if
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2233 // operating on the global stack.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2234
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2235 class G1CMKeepAliveAndDrainClosure: public OopClosure {
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2236 ConcurrentMark* _cm;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2237 CMTask* _task;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2238 int _ref_counter_limit;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2239 int _ref_counter;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2240 bool _is_serial;
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2241 public:
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2242 G1CMKeepAliveAndDrainClosure(ConcurrentMark* cm, CMTask* task, bool is_serial) :
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2243 _cm(cm), _task(task), _is_serial(is_serial),
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2244 _ref_counter_limit(G1RefProcDrainInterval) {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2245 assert(_ref_counter_limit > 0, "sanity");
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2246 assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code");
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2247 _ref_counter = _ref_counter_limit;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2248 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2249
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2250 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2251 virtual void do_oop( oop* p) { do_oop_work(p); }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2252
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2253 template <class T> void do_oop_work(T* p) {
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2254 if (!_cm->has_overflown()) {
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2255 oop obj = oopDesc::load_decode_heap_oop(p);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2256 if (_cm->verbose_high()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2257 gclog_or_tty->print_cr("\t[%u] we're looking at location "
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2258 "*"PTR_FORMAT" = "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2259 _task->worker_id(), p2i(p), p2i((void*) obj));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2260 }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2261
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2262 _task->deal_with_reference(obj);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2263 _ref_counter--;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2264
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2265 if (_ref_counter == 0) {
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2266 // We have dealt with _ref_counter_limit references, pushing them
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2267 // and objects reachable from them on to the local stack (and
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2268 // possibly the global stack). Call CMTask::do_marking_step() to
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2269 // process these entries.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2270 //
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2271 // We call CMTask::do_marking_step() in a loop, which we'll exit if
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2272 // there's nothing more to do (i.e. we're done with the entries that
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2273 // were pushed as a result of the CMTask::deal_with_reference() calls
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2274 // above) or we overflow.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2275 //
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2276 // Note: CMTask::do_marking_step() can set the CMTask::has_aborted()
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2277 // flag while there may still be some work to do. (See the comment at
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2278 // the beginning of CMTask::do_marking_step() for those conditions -
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2279 // one of which is reaching the specified time target.) It is only
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2280 // when CMTask::do_marking_step() returns without setting the
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2281 // has_aborted() flag that the marking step has completed.
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2282 do {
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2283 double mark_step_duration_ms = G1ConcMarkStepDurationMillis;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2284 _task->do_marking_step(mark_step_duration_ms,
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2285 false /* do_termination */,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2286 _is_serial);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2287 } while (_task->has_aborted() && !_cm->has_overflown());
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2288 _ref_counter = _ref_counter_limit;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2289 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2290 } else {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2291 if (_cm->verbose_high()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2292 gclog_or_tty->print_cr("\t[%u] CM Overflow", _task->worker_id());
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2293 }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2294 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2295 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2296 };
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2297
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2298 // 'Drain' oop closure used by both serial and parallel reference processing.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2299 // Uses the CMTask associated with a given worker thread (for serial
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2300 // reference processing the CMtask for worker 0 is used). Calls the
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2301 // do_marking_step routine, with an unbelievably large timeout value,
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2302 // to drain the marking data structures of the remaining entries
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2303 // added by the 'keep alive' oop closure above.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2304
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2305 class G1CMDrainMarkingStackClosure: public VoidClosure {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2306 ConcurrentMark* _cm;
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2307 CMTask* _task;
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2308 bool _is_serial;
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2309 public:
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2310 G1CMDrainMarkingStackClosure(ConcurrentMark* cm, CMTask* task, bool is_serial) :
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2311 _cm(cm), _task(task), _is_serial(is_serial) {
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2312 assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code");
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2313 }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2314
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2315 void do_void() {
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2316 do {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2317 if (_cm->verbose_high()) {
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2318 gclog_or_tty->print_cr("\t[%u] Drain: Calling do_marking_step - serial: %s",
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2319 _task->worker_id(), BOOL_TO_STR(_is_serial));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2320 }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2321
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2322 // We call CMTask::do_marking_step() to completely drain the local
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2323 // and global marking stacks of entries pushed by the 'keep alive'
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2324 // oop closure (an instance of G1CMKeepAliveAndDrainClosure above).
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2325 //
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2326 // CMTask::do_marking_step() is called in a loop, which we'll exit
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2327 // if there's nothing more to do (i.e. we'completely drained the
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2328 // entries that were pushed as a a result of applying the 'keep alive'
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2329 // closure to the entries on the discovered ref lists) or we overflow
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2330 // the global marking stack.
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2331 //
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2332 // Note: CMTask::do_marking_step() can set the CMTask::has_aborted()
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2333 // flag while there may still be some work to do. (See the comment at
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2334 // the beginning of CMTask::do_marking_step() for those conditions -
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2335 // one of which is reaching the specified time target.) It is only
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2336 // when CMTask::do_marking_step() returns without setting the
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2337 // has_aborted() flag that the marking step has completed.
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2338
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2339 _task->do_marking_step(1000000000.0 /* something very large */,
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2340 true /* do_termination */,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2341 _is_serial);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2342 } while (_task->has_aborted() && !_cm->has_overflown());
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2343 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2344 };
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2345
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2346 // Implementation of AbstractRefProcTaskExecutor for parallel
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2347 // reference processing at the end of G1 concurrent marking
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2348
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2349 class G1CMRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2350 private:
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2351 G1CollectedHeap* _g1h;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2352 ConcurrentMark* _cm;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2353 WorkGang* _workers;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2354 int _active_workers;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2355
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2356 public:
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2357 G1CMRefProcTaskExecutor(G1CollectedHeap* g1h,
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2358 ConcurrentMark* cm,
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2359 WorkGang* workers,
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2360 int n_workers) :
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
2361 _g1h(g1h), _cm(cm),
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
2362 _workers(workers), _active_workers(n_workers) { }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2363
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2364 // Executes the given task using concurrent marking worker threads.
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2365 virtual void execute(ProcessTask& task);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2366 virtual void execute(EnqueueTask& task);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2367 };
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2368
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2369 class G1CMRefProcTaskProxy: public AbstractGangTask {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2370 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2371 ProcessTask& _proc_task;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2372 G1CollectedHeap* _g1h;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2373 ConcurrentMark* _cm;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2374
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2375 public:
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2376 G1CMRefProcTaskProxy(ProcessTask& proc_task,
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2377 G1CollectedHeap* g1h,
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
2378 ConcurrentMark* cm) :
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2379 AbstractGangTask("Process reference objects in parallel"),
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2380 _proc_task(proc_task), _g1h(g1h), _cm(cm) {
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2381 ReferenceProcessor* rp = _g1h->ref_processor_cm();
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2382 assert(rp->processing_is_mt(), "shouldn't be here otherwise");
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2383 }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2384
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2385 virtual void work(uint worker_id) {
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2386 CMTask* task = _cm->task(worker_id);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2387 G1CMIsAliveClosure g1_is_alive(_g1h);
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2388 G1CMKeepAliveAndDrainClosure g1_par_keep_alive(_cm, task, false /* is_serial */);
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2389 G1CMDrainMarkingStackClosure g1_par_drain(_cm, task, false /* is_serial */);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2390
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2391 _proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, g1_par_drain);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2392 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2393 };
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2394
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2395 void G1CMRefProcTaskExecutor::execute(ProcessTask& proc_task) {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2396 assert(_workers != NULL, "Need parallel worker threads.");
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2397 assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2398
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
2399 G1CMRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _cm);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2400
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2401 // We need to reset the concurrency level before each
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2402 // proxy task execution, so that the termination protocol
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2403 // and overflow handling in CMTask::do_marking_step() knows
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2404 // how many workers to wait for.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2405 _cm->set_concurrency(_active_workers);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2406 _g1h->set_par_threads(_active_workers);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2407 _workers->run_task(&proc_task_proxy);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2408 _g1h->set_par_threads(0);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2409 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2410
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2411 class G1CMRefEnqueueTaskProxy: public AbstractGangTask {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2412 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2413 EnqueueTask& _enq_task;
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2414
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2415 public:
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2416 G1CMRefEnqueueTaskProxy(EnqueueTask& enq_task) :
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2417 AbstractGangTask("Enqueue reference objects in parallel"),
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
2418 _enq_task(enq_task) { }
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2419
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2420 virtual void work(uint worker_id) {
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2421 _enq_task.work(worker_id);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2422 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2423 };
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2424
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2425 void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2426 assert(_workers != NULL, "Need parallel worker threads.");
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2427 assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2428
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2429 G1CMRefEnqueueTaskProxy enq_task_proxy(enq_task);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2430
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2431 // Not strictly necessary but...
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2432 //
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2433 // We need to reset the concurrency level before each
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2434 // proxy task execution, so that the termination protocol
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2435 // and overflow handling in CMTask::do_marking_step() knows
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2436 // how many workers to wait for.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2437 _cm->set_concurrency(_active_workers);
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2438 _g1h->set_par_threads(_active_workers);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2439 _workers->run_task(&enq_task_proxy);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2440 _g1h->set_par_threads(0);
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2441 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2442
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2443 void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2444 if (has_overflown()) {
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2445 // Skip processing the discovered references if we have
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2446 // overflown the global marking stack. Reference objects
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2447 // only get discovered once so it is OK to not
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2448 // de-populate the discovered reference lists. We could have,
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2449 // but the only benefit would be that, when marking restarts,
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2450 // less reference objects are discovered.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2451 return;
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2452 }
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2453
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2454 ResourceMark rm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2455 HandleMark hm;
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2456
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2457 G1CollectedHeap* g1h = G1CollectedHeap::heap();
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2458
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2459 // Is alive closure.
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2460 G1CMIsAliveClosure g1_is_alive(g1h);
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2461
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2462 // Inner scope to exclude the cleaning of the string and symbol
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2463 // tables from the displayed time.
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2464 {
6007
5c86f8211d1e 7160728: Introduce an extra logging level for G1 logging
brutisso
parents: 5988
diff changeset
2465 if (G1Log::finer()) {
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2466 gclog_or_tty->put(' ');
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2467 }
20190
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
2468 GCTraceTime t("GC ref-proc", G1Log::finer(), false, g1h->gc_timer_cm(), concurrent_gc_id());
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2469
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2470 ReferenceProcessor* rp = g1h->ref_processor_cm();
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2471
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2472 // See the comment in G1CollectedHeap::ref_processing_init()
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2473 // about how reference processing currently works in G1.
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2474
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2475 // Set the soft reference policy
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2476 rp->setup_policy(clear_all_soft_refs);
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2477 assert(_markStack.isEmpty(), "mark stack should be empty");
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2478
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2479 // Instances of the 'Keep Alive' and 'Complete GC' closures used
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2480 // in serial reference processing. Note these closures are also
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2481 // used for serially processing (by the the current thread) the
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2482 // JNI references during parallel reference processing.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2483 //
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2484 // These closures do not need to synchronize with the worker
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2485 // threads involved in parallel reference processing as these
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2486 // instances are executed serially by the current thread (e.g.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2487 // reference processing is not multi-threaded and is thus
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2488 // performed by the current thread instead of a gang worker).
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2489 //
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2490 // The gang tasks involved in parallel reference procssing create
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2491 // their own instances of these closures, which do their own
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2492 // synchronization among themselves.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2493 G1CMKeepAliveAndDrainClosure g1_keep_alive(this, task(0), true /* is_serial */);
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2494 G1CMDrainMarkingStackClosure g1_drain_mark_stack(this, task(0), true /* is_serial */);
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2495
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2496 // We need at least one active thread. If reference processing
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2497 // is not multi-threaded we use the current (VMThread) thread,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2498 // otherwise we use the work gang from the G1CollectedHeap and
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2499 // we utilize all the worker threads we can.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2500 bool processing_is_mt = rp->processing_is_mt() && g1h->workers() != NULL;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2501 uint active_workers = (processing_is_mt ? g1h->workers()->active_workers() : 1U);
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2502 active_workers = MAX2(MIN2(active_workers, _max_worker_id), 1U);
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2503
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2504 // Parallel processing task executor.
4093
6071e0581859 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 4072
diff changeset
2505 G1CMRefProcTaskExecutor par_task_executor(g1h, this,
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2506 g1h->workers(), active_workers);
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2507 AbstractRefProcTaskExecutor* executor = (processing_is_mt ? &par_task_executor : NULL);
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2508
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2509 // Set the concurrency level. The phase was already set prior to
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2510 // executing the remark task.
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2511 set_concurrency(active_workers);
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2512
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2513 // Set the degree of MT processing here. If the discovery was done MT,
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2514 // the number of threads involved during discovery could differ from
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2515 // the number of active workers. This is OK as long as the discovered
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2516 // Reference lists are balanced (see balance_all_queues() and balance_queues()).
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2517 rp->set_active_mt_degree(active_workers);
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2518
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2519 // Process the weak references.
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2520 const ReferenceProcessorStats& stats =
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2521 rp->process_discovered_references(&g1_is_alive,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2522 &g1_keep_alive,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2523 &g1_drain_mark_stack,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2524 executor,
20190
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
2525 g1h->gc_timer_cm(),
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
2526 concurrent_gc_id());
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
2527 g1h->gc_tracer_cm()->report_gc_reference_stats(stats);
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2528
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2529 // The do_oop work routines of the keep_alive and drain_marking_stack
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2530 // oop closures will set the has_overflown flag if we overflow the
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2531 // global marking stack.
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2532
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2533 assert(_markStack.overflow() || _markStack.isEmpty(),
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2534 "mark stack should be empty (unless it overflowed)");
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2535
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2536 if (_markStack.overflow()) {
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2537 // This should have been done already when we tried to push an
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2538 // entry on to the global mark stack. But let's do it again.
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2539 set_has_overflown();
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2540 }
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2541
8014
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2542 assert(rp->num_q() == active_workers, "why not");
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2543
f90b9bceb8e5 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 8008
diff changeset
2544 rp->enqueue_discovered_references(executor);
3975
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2545
1847b501ae74 7068215: G1: Print reference processing time during remark
johnc
parents: 3914
diff changeset
2546 rp->verify_no_references_recorded();
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
2547 assert(!rp->discovery_enabled(), "Post condition");
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2548 }
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2549
17750
f53edbc2b728 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 17736
diff changeset
2550 if (has_overflown()) {
f53edbc2b728 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 17736
diff changeset
2551 // We can not trust g1_is_alive if the marking stack overflowed
f53edbc2b728 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 17736
diff changeset
2552 return;
f53edbc2b728 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 17736
diff changeset
2553 }
f53edbc2b728 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 17736
diff changeset
2554
17635
cb7ec2423207 8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
tschatzl
parents: 17634
diff changeset
2555 g1h->unlink_string_and_symbol_table(&g1_is_alive,
cb7ec2423207 8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
tschatzl
parents: 17634
diff changeset
2556 /* process_strings */ false, // currently strings are always roots
cb7ec2423207 8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
tschatzl
parents: 17634
diff changeset
2557 /* process_symbols */ true);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2558 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2559
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2560 void ConcurrentMark::swapMarkBitMaps() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2561 CMBitMapRO* temp = _prevMarkBitMap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2562 _prevMarkBitMap = (CMBitMapRO*)_nextMarkBitMap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2563 _nextMarkBitMap = (CMBitMap*) temp;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2564 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2565
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2566 class CMRemarkTask: public AbstractGangTask {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2567 private:
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2568 ConcurrentMark* _cm;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2569 bool _is_serial;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2570 public:
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2571 void work(uint worker_id) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2572 // Since all available tasks are actually started, we should
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2573 // only proceed if we're supposed to be actived.
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2574 if (worker_id < _cm->active_tasks()) {
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2575 CMTask* task = _cm->task(worker_id);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2576 task->record_start_time();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2577 do {
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
2578 task->do_marking_step(1000000000.0 /* something very large */,
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2579 true /* do_termination */,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2580 _is_serial);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2581 } while (task->has_aborted() && !_cm->has_overflown());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2582 // If we overflow, then we do not want to restart. We instead
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2583 // want to abort remark and do concurrent marking again.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2584 task->record_end_time();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2585 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2586 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2587
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2588 CMRemarkTask(ConcurrentMark* cm, int active_workers, bool is_serial) :
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2589 AbstractGangTask("Par Remark"), _cm(cm), _is_serial(is_serial) {
4711
adedfbbf0360 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 4097
diff changeset
2590 _cm->terminator()->reset_for_reuse(active_workers);
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2591 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2592 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2593
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2594 void ConcurrentMark::checkpointRootsFinalWork() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2595 ResourceMark rm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2596 HandleMark hm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2597 G1CollectedHeap* g1h = G1CollectedHeap::heap();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2598
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2599 g1h->ensure_parsability(false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2600
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
2601 if (G1CollectedHeap::use_parallel_gc_threads()) {
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 912
diff changeset
2602 G1CollectedHeap::StrongRootsScope srs(g1h);
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2603 // this is remark, so we'll use up all active threads
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2604 uint active_workers = g1h->workers()->active_workers();
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2605 if (active_workers == 0) {
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2606 assert(active_workers > 0, "Should have been set earlier");
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2607 active_workers = (uint) ParallelGCThreads;
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2608 g1h->workers()->set_active_workers(active_workers);
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2609 }
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2610 set_concurrency_and_phase(active_workers, false /* concurrent */);
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2611 // Leave _parallel_marking_threads at it's
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2612 // value originally calculated in the ConcurrentMark
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2613 // constructor and pass values of the active workers
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2614 // through the gang in the task.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2615
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2616 CMRemarkTask remarkTask(this, active_workers, false /* is_serial */);
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2617 // We will start all available threads, even if we decide that the
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2618 // active_workers will be fewer. The extra ones will just bail out
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2619 // immediately.
4095
bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 4093
diff changeset
2620 g1h->set_par_threads(active_workers);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2621 g1h->workers()->run_task(&remarkTask);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2622 g1h->set_par_threads(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2623 } else {
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 912
diff changeset
2624 G1CollectedHeap::StrongRootsScope srs(g1h);
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
2625 uint active_workers = 1;
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
2626 set_concurrency_and_phase(active_workers, false /* concurrent */);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2627
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2628 // Note - if there's no work gang then the VMThread will be
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2629 // the thread to execute the remark - serially. We have
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2630 // to pass true for the is_serial parameter so that
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2631 // CMTask::do_marking_step() doesn't enter the sync
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2632 // barriers in the event of an overflow. Doing so will
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2633 // cause an assert that the current thread is not a
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2634 // concurrent GC thread.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
2635 CMRemarkTask remarkTask(this, active_workers, true /* is_serial*/);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2636 remarkTask.work(0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2637 }
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2638 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
8789
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
2639 guarantee(has_overflown() ||
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
2640 satb_mq_set.completed_buffers_num() == 0,
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
2641 err_msg("Invariant: has_overflown = %s, num buffers = %d",
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
2642 BOOL_TO_STR(has_overflown()),
1179172e9ec9 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 8788
diff changeset
2643 satb_mq_set.completed_buffers_num()));
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2644
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2645 print_stats();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2646 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2647
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2648 #ifndef PRODUCT
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2649
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2650 class PrintReachableOopClosure: public OopClosure {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2651 private:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2652 G1CollectedHeap* _g1h;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2653 outputStream* _out;
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2654 VerifyOption _vo;
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2655 bool _all;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2656
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2657 public:
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2658 PrintReachableOopClosure(outputStream* out,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2659 VerifyOption vo,
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2660 bool all) :
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2661 _g1h(G1CollectedHeap::heap()),
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2662 _out(out), _vo(vo), _all(all) { }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2663
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2664 void do_oop(narrowOop* p) { do_oop_work(p); }
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2665 void do_oop( oop* p) { do_oop_work(p); }
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2666
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2667 template <class T> void do_oop_work(T* p) {
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 831
diff changeset
2668 oop obj = oopDesc::load_decode_heap_oop(p);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2669 const char* str = NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2670 const char* str2 = "";
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2671
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2672 if (obj == NULL) {
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2673 str = "";
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2674 } else if (!_g1h->is_in_g1_reserved(obj)) {
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2675 str = " O";
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2676 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2677 HeapRegion* hr = _g1h->heap_region_containing(obj);
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2678 guarantee(hr != NULL, "invariant");
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2679 bool over_tams = _g1h->allocated_since_marking(obj, hr, _vo);
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2680 bool marked = _g1h->is_marked(obj, _vo);
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2681
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2682 if (over_tams) {
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2683 str = " >";
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2684 if (marked) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2685 str2 = " AND MARKED";
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2686 }
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2687 } else if (marked) {
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2688 str = " M";
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2689 } else {
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2690 str = " NOT";
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2691 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2692 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2693
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2694 _out->print_cr(" "PTR_FORMAT": "PTR_FORMAT"%s%s",
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2695 p2i(p), p2i((void*) obj), str, str2);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2696 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2697 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2698
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2699 class PrintReachableObjectClosure : public ObjectClosure {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2700 private:
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2701 G1CollectedHeap* _g1h;
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2702 outputStream* _out;
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2703 VerifyOption _vo;
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2704 bool _all;
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2705 HeapRegion* _hr;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2706
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2707 public:
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2708 PrintReachableObjectClosure(outputStream* out,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2709 VerifyOption vo,
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2710 bool all,
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2711 HeapRegion* hr) :
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2712 _g1h(G1CollectedHeap::heap()),
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2713 _out(out), _vo(vo), _all(all), _hr(hr) { }
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2714
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2715 void do_object(oop o) {
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2716 bool over_tams = _g1h->allocated_since_marking(o, _hr, _vo);
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2717 bool marked = _g1h->is_marked(o, _vo);
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2718 bool print_it = _all || over_tams || marked;
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2719
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2720 if (print_it) {
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2721 _out->print_cr(" "PTR_FORMAT"%s",
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2722 p2i((void *)o), (over_tams) ? " >" : (marked) ? " M" : "");
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2723 PrintReachableOopClosure oopCl(_out, _vo, _all);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 6254
diff changeset
2724 o->oop_iterate_no_header(&oopCl);
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2725 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2726 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2727 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2728
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2729 class PrintReachableRegionClosure : public HeapRegionClosure {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2730 private:
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2731 G1CollectedHeap* _g1h;
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2732 outputStream* _out;
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2733 VerifyOption _vo;
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2734 bool _all;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2735
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2736 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2737 bool doHeapRegion(HeapRegion* hr) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2738 HeapWord* b = hr->bottom();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2739 HeapWord* e = hr->end();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2740 HeapWord* t = hr->top();
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2741 HeapWord* p = _g1h->top_at_mark_start(hr, _vo);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2742 _out->print_cr("** ["PTR_FORMAT", "PTR_FORMAT"] top: "PTR_FORMAT" "
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2743 "TAMS: " PTR_FORMAT, p2i(b), p2i(e), p2i(t), p2i(p));
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2744 _out->cr();
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2745
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2746 HeapWord* from = b;
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2747 HeapWord* to = t;
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2748
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2749 if (to > from) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2750 _out->print_cr("Objects in [" PTR_FORMAT ", " PTR_FORMAT "]", p2i(from), p2i(to));
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2751 _out->cr();
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2752 PrintReachableObjectClosure ocl(_out, _vo, _all, hr);
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2753 hr->object_iterate_mem_careful(MemRegion(from, to), &ocl);
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2754 _out->cr();
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2755 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2756
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2757 return false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2758 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2759
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2760 PrintReachableRegionClosure(outputStream* out,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2761 VerifyOption vo,
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2762 bool all) :
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2763 _g1h(G1CollectedHeap::heap()), _out(out), _vo(vo), _all(all) { }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2764 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2765
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2766 void ConcurrentMark::print_reachable(const char* str,
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2767 VerifyOption vo,
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2768 bool all) {
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2769 gclog_or_tty->cr();
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2770 gclog_or_tty->print_cr("== Doing heap dump... ");
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2771
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2772 if (G1PrintReachableBaseFile == NULL) {
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2773 gclog_or_tty->print_cr(" #### error: no base file defined");
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2774 return;
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2775 }
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2776
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2777 if (strlen(G1PrintReachableBaseFile) + 1 + strlen(str) >
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2778 (JVM_MAXPATHLEN - 1)) {
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2779 gclog_or_tty->print_cr(" #### error: file name too long");
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2780 return;
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2781 }
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2782
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2783 char file_name[JVM_MAXPATHLEN];
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2784 sprintf(file_name, "%s.%s", G1PrintReachableBaseFile, str);
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2785 gclog_or_tty->print_cr(" dumping to file %s", file_name);
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2786
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2787 fileStream fout(file_name);
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2788 if (!fout.is_open()) {
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2789 gclog_or_tty->print_cr(" #### error: could not open file");
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2790 return;
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2791 }
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2792
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2793 outputStream* out = &fout;
6254
a2f7274eb6ef 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 6220
diff changeset
2794 out->print_cr("-- USING %s", _g1h->top_at_mark_start_str(vo));
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2795 out->cr();
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2796
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2797 out->print_cr("--- ITERATING OVER REGIONS");
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2798 out->cr();
3772
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 3771
diff changeset
2799 PrintReachableRegionClosure rcl(out, vo, all);
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2800 _g1h->heap_region_iterate(&rcl);
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2801 out->cr();
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2802
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2803 gclog_or_tty->print_cr(" done");
1388
7666957bc44d 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 1359
diff changeset
2804 gclog_or_tty->flush();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2805 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2806
1044
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2807 #endif // PRODUCT
6270f80a7331 6890137: G1: revamp reachable object dump
tonyp
parents: 1030
diff changeset
2808
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2809 void ConcurrentMark::clearRangePrevBitmap(MemRegion mr) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2810 // Note we are overriding the read-only view of the prev map here, via
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2811 // the cast.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2812 ((CMBitMap*)_prevMarkBitMap)->clearRange(mr);
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2813 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2814
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2815 void ConcurrentMark::clearRangeNextBitmap(MemRegion mr) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2816 _nextMarkBitMap->clearRange(mr);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2817 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2818
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2819 void ConcurrentMark::clearRangeBothBitmaps(MemRegion mr) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2820 clearRangePrevBitmap(mr);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2821 clearRangeNextBitmap(mr);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2822 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2823
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2824 HeapRegion*
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2825 ConcurrentMark::claim_region(uint worker_id) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2826 // "checkpoint" the finger
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2827 HeapWord* finger = _finger;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2828
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2829 // _heap_end will not change underneath our feet; it only changes at
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2830 // yield points.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2831 while (finger < _heap_end) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2832 assert(_g1h->is_in_g1_reserved(finger), "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2833
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2834 // Note on how this code handles humongous regions. In the
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2835 // normal case the finger will reach the start of a "starts
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2836 // humongous" (SH) region. Its end will either be the end of the
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2837 // last "continues humongous" (CH) region in the sequence, or the
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2838 // standard end of the SH region (if the SH is the only region in
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2839 // the sequence). That way claim_region() will skip over the CH
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2840 // regions. However, there is a subtle race between a CM thread
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2841 // executing this method and a mutator thread doing a humongous
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2842 // object allocation. The two are not mutually exclusive as the CM
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2843 // thread does not need to hold the Heap_lock when it gets
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2844 // here. So there is a chance that claim_region() will come across
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2845 // a free region that's in the progress of becoming a SH or a CH
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2846 // region. In the former case, it will either
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2847 // a) Miss the update to the region's end, in which case it will
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2848 // visit every subsequent CH region, will find their bitmaps
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2849 // empty, and do nothing, or
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2850 // b) Will observe the update of the region's end (in which case
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2851 // it will skip the subsequent CH regions).
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2852 // If it comes across a region that suddenly becomes CH, the
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2853 // scenario will be similar to b). So, the race between
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2854 // claim_region() and a humongous object allocation might force us
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2855 // to do a bit of unnecessary work (due to some unnecessary bitmap
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2856 // iterations) but it should not introduce and correctness issues.
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2857 HeapRegion* curr_region = _g1h->heap_region_containing_raw(finger);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2858 HeapWord* bottom = curr_region->bottom();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2859 HeapWord* end = curr_region->end();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2860 HeapWord* limit = curr_region->next_top_at_mark_start();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2861
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2862 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2863 gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2864 "["PTR_FORMAT", "PTR_FORMAT"), "
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2865 "limit = "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2866 worker_id, p2i(curr_region), p2i(bottom), p2i(end), p2i(limit));
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2867 }
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2868
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2869 // Is the gap between reading the finger and doing the CAS too long?
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
2870 HeapWord* res = (HeapWord*) Atomic::cmpxchg_ptr(end, &_finger, finger);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2871 if (res == finger) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2872 // we succeeded
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2873
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2874 // notice that _finger == end cannot be guaranteed here since,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2875 // someone else might have moved the finger even further
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2876 assert(_finger >= end, "the finger should have moved forward");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2877
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2878 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2879 gclog_or_tty->print_cr("[%u] we were successful with region = "
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2880 PTR_FORMAT, worker_id, p2i(curr_region));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2881 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2882
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2883 if (limit > bottom) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2884 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2885 gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, "
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2886 "returning it ", worker_id, p2i(curr_region));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2887 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2888 return curr_region;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2889 } else {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2890 assert(limit == bottom,
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2891 "the region limit should be at bottom");
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2892 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2893 gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, "
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2894 "returning NULL", worker_id, p2i(curr_region));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2895 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2896 // we return NULL and the caller should try calling
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2897 // claim_region() again.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2898 return NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2899 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2900 } else {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
2901 assert(_finger > finger, "the finger should have moved forward");
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2902 if (verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2903 gclog_or_tty->print_cr("[%u] somebody else moved the finger, "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2904 "global finger = "PTR_FORMAT", "
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2905 "our finger = "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2906 worker_id, p2i(_finger), p2i(finger));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
2907 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2908
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2909 // read it again
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2910 finger = _finger;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2911 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2912 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2913
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2914 return NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2915 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2916
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2917 #ifndef PRODUCT
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2918 enum VerifyNoCSetOopsPhase {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2919 VerifyNoCSetOopsStack,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2920 VerifyNoCSetOopsQueues,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2921 VerifyNoCSetOopsSATBCompleted,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2922 VerifyNoCSetOopsSATBThread
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2923 };
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2924
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2925 class VerifyNoCSetOopsClosure : public OopClosure, public ObjectClosure {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2926 private:
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2927 G1CollectedHeap* _g1h;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2928 VerifyNoCSetOopsPhase _phase;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2929 int _info;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2930
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2931 const char* phase_str() {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2932 switch (_phase) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2933 case VerifyNoCSetOopsStack: return "Stack";
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2934 case VerifyNoCSetOopsQueues: return "Queue";
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2935 case VerifyNoCSetOopsSATBCompleted: return "Completed SATB Buffers";
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2936 case VerifyNoCSetOopsSATBThread: return "Thread SATB Buffers";
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2937 default: ShouldNotReachHere();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2938 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2939 return NULL;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2940 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2941
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2942 void do_object_work(oop obj) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2943 guarantee(!_g1h->obj_in_cs(obj),
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2944 err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d",
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
2945 p2i((void*) obj), phase_str(), _info));
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2946 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2947
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2948 public:
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2949 VerifyNoCSetOopsClosure() : _g1h(G1CollectedHeap::heap()) { }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2950
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2951 void set_phase(VerifyNoCSetOopsPhase phase, int info = -1) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2952 _phase = phase;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2953 _info = info;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2954 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2955
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2956 virtual void do_oop(oop* p) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2957 oop obj = oopDesc::load_decode_heap_oop(p);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2958 do_object_work(obj);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2959 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2960
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2961 virtual void do_oop(narrowOop* p) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2962 // We should not come across narrow oops while scanning marking
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2963 // stacks and SATB buffers.
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2964 ShouldNotReachHere();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2965 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2966
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2967 virtual void do_object(oop obj) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2968 do_object_work(obj);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2969 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2970 };
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2971
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2972 void ConcurrentMark::verify_no_cset_oops(bool verify_stacks,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2973 bool verify_enqueued_buffers,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2974 bool verify_thread_buffers,
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2975 bool verify_fingers) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2976 assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2977 if (!G1CollectedHeap::heap()->mark_in_progress()) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2978 return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
2979 }
1835
4805b9f4779e 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 1833
diff changeset
2980
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2981 VerifyNoCSetOopsClosure cl;
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2982
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2983 if (verify_stacks) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2984 // Verify entries on the global mark stack
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2985 cl.set_phase(VerifyNoCSetOopsStack);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2986 _markStack.oops_do(&cl);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2987
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2988 // Verify entries on the task queues
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
2989 for (uint i = 0; i < _max_worker_id; i += 1) {
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2990 cl.set_phase(VerifyNoCSetOopsQueues, i);
7397
442f942757c0 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 6865
diff changeset
2991 CMTaskQueue* queue = _task_queues->queue(i);
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2992 queue->oops_do(&cl);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2993 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2994 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2995
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2996 SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2997
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2998 // Verify entries on the enqueued SATB buffers
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
2999 if (verify_enqueued_buffers) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3000 cl.set_phase(VerifyNoCSetOopsSATBCompleted);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3001 satb_qs.iterate_completed_buffers_read_only(&cl);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3002 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3003
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3004 // Verify entries on the per-thread SATB buffers
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3005 if (verify_thread_buffers) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3006 cl.set_phase(VerifyNoCSetOopsSATBThread);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3007 satb_qs.iterate_thread_buffers_read_only(&cl);
1835
4805b9f4779e 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 1833
diff changeset
3008 }
4805b9f4779e 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 1833
diff changeset
3009
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3010 if (verify_fingers) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3011 // Verify the global finger
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3012 HeapWord* global_finger = finger();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3013 if (global_finger != NULL && global_finger < _heap_end) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3014 // The global finger always points to a heap region boundary. We
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3015 // use heap_region_containing_raw() to get the containing region
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3016 // given that the global finger could be pointing to a free region
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3017 // which subsequently becomes continues humongous. If that
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3018 // happens, heap_region_containing() will return the bottom of the
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3019 // corresponding starts humongous region and the check below will
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3020 // not hold any more.
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3021 HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3022 guarantee(global_finger == global_hr->bottom(),
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3023 err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3024 p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3025 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3026
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3027 // Verify the task fingers
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3028 assert(parallel_marking_threads() <= _max_worker_id, "sanity");
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3029 for (int i = 0; i < (int) parallel_marking_threads(); i += 1) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3030 CMTask* task = _tasks[i];
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3031 HeapWord* task_finger = task->finger();
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3032 if (task_finger != NULL && task_finger < _heap_end) {
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3033 // See above note on the global finger verification.
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3034 HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3035 guarantee(task_finger == task_hr->bottom() ||
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3036 !task_hr->in_collection_set(),
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3037 err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3038 p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3039 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3040 }
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3041 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3042 }
4787
2ace1c4ee8da 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 4783
diff changeset
3043 #endif // PRODUCT
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3044
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3045 // Aggregate the counting data that was constructed concurrently
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3046 // with marking.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3047 class AggregateCountDataHRClosure: public HeapRegionClosure {
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3048 G1CollectedHeap* _g1h;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3049 ConcurrentMark* _cm;
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3050 CardTableModRefBS* _ct_bs;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3051 BitMap* _cm_card_bm;
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3052 uint _max_worker_id;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3053
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3054 public:
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3055 AggregateCountDataHRClosure(G1CollectedHeap* g1h,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3056 BitMap* cm_card_bm,
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3057 uint max_worker_id) :
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3058 _g1h(g1h), _cm(g1h->concurrent_mark()),
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3059 _ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3060 _cm_card_bm(cm_card_bm), _max_worker_id(max_worker_id) { }
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3061
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3062 bool doHeapRegion(HeapRegion* hr) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3063 if (hr->continuesHumongous()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3064 // We will ignore these here and process them when their
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3065 // associated "starts humongous" region is processed.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3066 // Note that we cannot rely on their associated
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3067 // "starts humongous" region to have their bit set to 1
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3068 // since, due to the region chunking in the parallel region
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3069 // iteration, a "continues humongous" region might be visited
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3070 // before its associated "starts humongous".
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3071 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3072 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3073
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3074 HeapWord* start = hr->bottom();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3075 HeapWord* limit = hr->next_top_at_mark_start();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3076 HeapWord* end = hr->end();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3077
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3078 assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3079 err_msg("Preconditions not met - "
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3080 "start: "PTR_FORMAT", limit: "PTR_FORMAT", "
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3081 "top: "PTR_FORMAT", end: "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3082 p2i(start), p2i(limit), p2i(hr->top()), p2i(hr->end())));
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3083
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3084 assert(hr->next_marked_bytes() == 0, "Precondition");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3085
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3086 if (start == limit) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3087 // NTAMS of this region has not been set so nothing to do.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3088 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3089 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3090
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3091 // 'start' should be in the heap.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3092 assert(_g1h->is_in_g1_reserved(start) && _ct_bs->is_card_aligned(start), "sanity");
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3093 // 'end' *may* be just beyone the end of the heap (if hr is the last region)
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3094 assert(!_g1h->is_in_g1_reserved(end) || _ct_bs->is_card_aligned(end), "sanity");
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3095
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3096 BitMap::idx_t start_idx = _cm->card_bitmap_index_for(start);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3097 BitMap::idx_t limit_idx = _cm->card_bitmap_index_for(limit);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3098 BitMap::idx_t end_idx = _cm->card_bitmap_index_for(end);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3099
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3100 // If ntams is not card aligned then we bump card bitmap index
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3101 // for limit so that we get the all the cards spanned by
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3102 // the object ending at ntams.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3103 // Note: if this is the last region in the heap then ntams
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3104 // could be actually just beyond the end of the the heap;
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3105 // limit_idx will then correspond to a (non-existent) card
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3106 // that is also outside the heap.
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3107 if (_g1h->is_in_g1_reserved(limit) && !_ct_bs->is_card_aligned(limit)) {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3108 limit_idx += 1;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3109 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3110
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3111 assert(limit_idx <= end_idx, "or else use atomics");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3112
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3113 // Aggregate the "stripe" in the count data associated with hr.
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
3114 uint hrs_index = hr->hrs_index();
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3115 size_t marked_bytes = 0;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3116
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3117 for (uint i = 0; i < _max_worker_id; i += 1) {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3118 size_t* marked_bytes_array = _cm->count_marked_bytes_array_for(i);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3119 BitMap* task_card_bm = _cm->count_card_bitmap_for(i);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3120
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3121 // Fetch the marked_bytes in this region for task i and
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3122 // add it to the running total for this region.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3123 marked_bytes += marked_bytes_array[hrs_index];
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3124
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3125 // Now union the bitmaps[0,max_worker_id)[start_idx..limit_idx)
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3126 // into the global card bitmap.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3127 BitMap::idx_t scan_idx = task_card_bm->get_next_one_offset(start_idx, limit_idx);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3128
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3129 while (scan_idx < limit_idx) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3130 assert(task_card_bm->at(scan_idx) == true, "should be");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3131 _cm_card_bm->set_bit(scan_idx);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3132 assert(_cm_card_bm->at(scan_idx) == true, "should be");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3133
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3134 // BitMap::get_next_one_offset() can handle the case when
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3135 // its left_offset parameter is greater than its right_offset
6812
988bf00cc564 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 6750
diff changeset
3136 // parameter. It does, however, have an early exit if
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3137 // left_offset == right_offset. So let's limit the value
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3138 // passed in for left offset here.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3139 BitMap::idx_t next_idx = MIN2(scan_idx + 1, limit_idx);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3140 scan_idx = task_card_bm->get_next_one_offset(next_idx, limit_idx);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3141 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3142 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3143
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3144 // Update the marked bytes for this region.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3145 hr->add_to_marked_bytes(marked_bytes);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3146
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3147 // Next heap region
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3148 return false;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3149 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3150 };
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3151
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3152 class G1AggregateCountDataTask: public AbstractGangTask {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3153 protected:
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3154 G1CollectedHeap* _g1h;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3155 ConcurrentMark* _cm;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3156 BitMap* _cm_card_bm;
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3157 uint _max_worker_id;
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3158 int _active_workers;
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3159
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3160 public:
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3161 G1AggregateCountDataTask(G1CollectedHeap* g1h,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3162 ConcurrentMark* cm,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3163 BitMap* cm_card_bm,
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3164 uint max_worker_id,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3165 int n_workers) :
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3166 AbstractGangTask("Count Aggregation"),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3167 _g1h(g1h), _cm(cm), _cm_card_bm(cm_card_bm),
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3168 _max_worker_id(max_worker_id),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3169 _active_workers(n_workers) { }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3170
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3171 void work(uint worker_id) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3172 AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_worker_id);
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3173
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3174 if (G1CollectedHeap::use_parallel_gc_threads()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3175 _g1h->heap_region_par_iterate_chunked(&cl, worker_id,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3176 _active_workers,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3177 HeapRegion::AggregateCountClaimValue);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3178 } else {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3179 _g1h->heap_region_iterate(&cl);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3180 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3181 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3182 };
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3183
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3184
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3185 void ConcurrentMark::aggregate_count_data() {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3186 int n_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3187 _g1h->workers()->active_workers() :
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3188 1);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3189
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3190 G1AggregateCountDataTask g1_par_agg_task(_g1h, this, &_card_bm,
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3191 _max_worker_id, n_workers);
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3192
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3193 if (G1CollectedHeap::use_parallel_gc_threads()) {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3194 assert(_g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3195 "sanity check");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3196 _g1h->set_par_threads(n_workers);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3197 _g1h->workers()->run_task(&g1_par_agg_task);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3198 _g1h->set_par_threads(0);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3199
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3200 assert(_g1h->check_heap_region_claim_values(HeapRegion::AggregateCountClaimValue),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3201 "sanity check");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3202 _g1h->reset_heap_region_claim_values();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3203 } else {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3204 g1_par_agg_task.work(0);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3205 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3206 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3207
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3208 // Clear the per-worker arrays used to store the per-region counting data
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3209 void ConcurrentMark::clear_all_count_data() {
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3210 // Clear the global card bitmap - it will be filled during
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3211 // liveness count aggregation (during remark) and the
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3212 // final counting task.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3213 _card_bm.clear();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3214
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3215 // Clear the global region bitmap - it will be filled as part
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3216 // of the final counting task.
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3217 _region_bm.clear();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3218
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
3219 uint max_regions = _g1h->max_regions();
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3220 assert(_max_worker_id > 0, "uninitialized");
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3221
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3222 for (uint i = 0; i < _max_worker_id; i += 1) {
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3223 BitMap* task_card_bm = count_card_bitmap_for(i);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3224 size_t* marked_bytes_array = count_marked_bytes_array_for(i);
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3225
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3226 assert(task_card_bm->size() == _card_bm.size(), "size mismatch");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3227 assert(marked_bytes_array != NULL, "uninitialized");
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3228
6010
720b6a76dd9d 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 6008
diff changeset
3229 memset(marked_bytes_array, 0, (size_t) max_regions * sizeof(size_t));
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3230 task_card_bm->clear();
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3231 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3232 }
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3233
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3234 void ConcurrentMark::print_stats() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3235 if (verbose_stats()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3236 gclog_or_tty->print_cr("---------------------------------------------------------------------");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3237 for (size_t i = 0; i < _active_tasks; ++i) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3238 _tasks[i]->print_stats();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3239 gclog_or_tty->print_cr("---------------------------------------------------------------------");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3240 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3241 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3242 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3243
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3244 // abandon current marking iteration due to a Full GC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3245 void ConcurrentMark::abort() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3246 // Clear all marks to force marking thread to do nothing
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3247 _nextMarkBitMap->clearAll();
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3248 // Clear the liveness counting data
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3249 clear_all_count_data();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3250 // Empty mark stack
7450
d275c3dc73e6 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 7397
diff changeset
3251 reset_marking_state();
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3252 for (uint i = 0; i < _max_worker_id; ++i) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3253 _tasks[i]->clear_region_fields();
1835
4805b9f4779e 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 1833
diff changeset
3254 }
17949
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
3255 _first_overflow_barrier_sync.abort();
487f09bf44e0 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17937
diff changeset
3256 _second_overflow_barrier_sync.abort();
20190
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3257 const GCId& gc_id = _g1h->gc_tracer_cm()->gc_id();
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3258 if (!gc_id.is_undefined()) {
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3259 // We can do multiple full GCs before ConcurrentMarkThread::run() gets a chance
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3260 // to detect that it was aborted. Only keep track of the first GC id that we aborted.
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3261 _aborted_gc_id = gc_id;
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3262 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3263 _has_aborted = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3264
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3265 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3266 satb_mq_set.abandon_partial_marking();
1317
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
3267 // This can be called either during or outside marking, we'll read
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
3268 // the expected_active value from the SATB queue set.
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
3269 satb_mq_set.set_active_all_threads(
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
3270 false, /* new active value */
d4197f8d516a 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 1314
diff changeset
3271 satb_mq_set.is_active() /* expected_active */);
10405
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
3272
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
3273 _g1h->trace_heap_after_concurrent_cycle();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 10290
diff changeset
3274 _g1h->register_concurrent_cycle_end();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3275 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3276
20190
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3277 const GCId& ConcurrentMark::concurrent_gc_id() {
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3278 if (has_aborted()) {
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3279 return _aborted_gc_id;
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3280 }
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3281 return _g1h->gc_tracer_cm()->gc_id();
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3282 }
0982ec23da03 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 17950
diff changeset
3283
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3284 static void print_ms_time_info(const char* prefix, const char* name,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3285 NumberSeq& ns) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3286 gclog_or_tty->print_cr("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3287 prefix, ns.num(), name, ns.sum()/1000.0, ns.avg());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3288 if (ns.num() > 0) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3289 gclog_or_tty->print_cr("%s [std. dev = %8.2f ms, max = %8.2f ms]",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3290 prefix, ns.sd(), ns.maximum());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3291 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3292 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3293
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3294 void ConcurrentMark::print_summary_info() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3295 gclog_or_tty->print_cr(" Concurrent marking:");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3296 print_ms_time_info(" ", "init marks", _init_times);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3297 print_ms_time_info(" ", "remarks", _remark_times);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3298 {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3299 print_ms_time_info(" ", "final marks", _remark_mark_times);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3300 print_ms_time_info(" ", "weak refs", _remark_weak_ref_times);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3301
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3302 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3303 print_ms_time_info(" ", "cleanups", _cleanup_times);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3304 gclog_or_tty->print_cr(" Final counting total time = %8.2f s (avg = %8.2f ms).",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3305 _total_counting_time,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3306 (_cleanup_times.num() > 0 ? _total_counting_time * 1000.0 /
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3307 (double)_cleanup_times.num()
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3308 : 0.0));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3309 if (G1ScrubRemSets) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3310 gclog_or_tty->print_cr(" RS scrub total time = %8.2f s (avg = %8.2f ms).",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3311 _total_rs_scrub_time,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3312 (_cleanup_times.num() > 0 ? _total_rs_scrub_time * 1000.0 /
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3313 (double)_cleanup_times.num()
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3314 : 0.0));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3315 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3316 gclog_or_tty->print_cr(" Total stop_world time = %8.2f s.",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3317 (_init_times.sum() + _remark_times.sum() +
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3318 _cleanup_times.sum())/1000.0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3319 gclog_or_tty->print_cr(" Total concurrent time = %8.2f s "
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3320 "(%8.2f s marking).",
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3321 cmThread()->vtime_accum(),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
3322 cmThread()->vtime_mark_accum());
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3323 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3324
1019
035d2e036a9b 6885041: G1: inconsistent thread dump
tonyp
parents: 993
diff changeset
3325 void ConcurrentMark::print_worker_threads_on(outputStream* st) const {
8008
256d3f43c177 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 8006
diff changeset
3326 if (use_parallel_marking_threads()) {
256d3f43c177 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 8006
diff changeset
3327 _parallel_workers->print_worker_threads_on(st);
256d3f43c177 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 8006
diff changeset
3328 }
1019
035d2e036a9b 6885041: G1: inconsistent thread dump
tonyp
parents: 993
diff changeset
3329 }
035d2e036a9b 6885041: G1: inconsistent thread dump
tonyp
parents: 993
diff changeset
3330
9076
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
3331 void ConcurrentMark::print_on_error(outputStream* st) const {
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
3332 st->print_cr("Marking Bits (Prev, Next): (CMBitMap*) " PTR_FORMAT ", (CMBitMap*) " PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3333 p2i(_prevMarkBitMap), p2i(_nextMarkBitMap));
9076
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
3334 _prevMarkBitMap->print_on_error(st, " Prev Bits: ");
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
3335 _nextMarkBitMap->print_on_error(st, " Next Bits: ");
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
3336 }
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 8789
diff changeset
3337
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3338 // We take a break if someone is trying to stop the world.
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
3339 bool ConcurrentMark::do_yield_check(uint worker_id) {
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
3340 if (SuspendibleThreadSet::should_yield()) {
4728
441e946dc1af 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 4711
diff changeset
3341 if (worker_id == 0) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3342 _g1h->g1_policy()->record_concurrent_pause();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3343 }
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
3344 SuspendibleThreadSet::yield();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3345 return true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3346 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3347 return false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3348 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3349 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3350
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3351 bool ConcurrentMark::containing_card_is_marked(void* p) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3352 size_t offset = pointer_delta(p, _g1h->reserved_region().start(), 1);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3353 return _card_bm.at(offset >> CardTableModRefBS::card_shift);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3354 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3355
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3356 bool ConcurrentMark::containing_cards_are_marked(void* start,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3357 void* last) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3358 return containing_card_is_marked(start) &&
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3359 containing_card_is_marked(last);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3360 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3361
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3362 #ifndef PRODUCT
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3363 // for debugging purposes
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3364 void ConcurrentMark::print_finger() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3365 gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3366 p2i(_heap_start), p2i(_heap_end), p2i(_finger));
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3367 for (uint i = 0; i < _max_worker_id; ++i) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3368 gclog_or_tty->print(" %u: " PTR_FORMAT, i, p2i(_tasks[i]->finger()));
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3369 }
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3370 gclog_or_tty->cr();
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3371 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3372 #endif
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3373
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3374 void CMTask::scan_object(oop obj) {
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3375 assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3376
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3377 if (_cm->verbose_high()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3378 gclog_or_tty->print_cr("[%u] we're scanning object "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3379 _worker_id, p2i((void*) obj));
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3380 }
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3381
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3382 size_t obj_size = obj->size();
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3383 _words_scanned += obj_size;
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3384
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3385 obj->oop_iterate(_cm_oop_closure);
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3386 statsOnly( ++_objs_scanned );
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3387 check_limits();
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3388 }
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3389
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3390 // Closure for iteration over bitmaps
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3391 class CMBitMapClosure : public BitMapClosure {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3392 private:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3393 // the bitmap that is being iterated over
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3394 CMBitMap* _nextMarkBitMap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3395 ConcurrentMark* _cm;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3396 CMTask* _task;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3397
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3398 public:
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3399 CMBitMapClosure(CMTask *task, ConcurrentMark* cm, CMBitMap* nextMarkBitMap) :
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3400 _task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3401
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3402 bool do_bit(size_t offset) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3403 HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset);
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3404 assert(_nextMarkBitMap->isMarked(addr), "invariant");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3405 assert( addr < _cm->finger(), "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3406
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3407 statsOnly( _task->increase_objs_found_on_bitmap() );
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3408 assert(addr >= _task->finger(), "invariant");
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3409
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3410 // We move that task's local finger along.
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3411 _task->move_finger_to(addr);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3412
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3413 _task->scan_object(oop(addr));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3414 // we only partially drain the local queue and global stack
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3415 _task->drain_local_queue(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3416 _task->drain_global_stack(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3417
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3418 // if the has_aborted flag has been raised, we need to bail out of
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3419 // the iteration
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3420 return !_task->has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3421 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3422 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3423
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3424 // Closure for iterating over objects, currently only used for
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3425 // processing SATB buffers.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3426 class CMObjectClosure : public ObjectClosure {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3427 private:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3428 CMTask* _task;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3429
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3430 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3431 void do_object(oop obj) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3432 _task->deal_with_reference(obj);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3433 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3434
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3435 CMObjectClosure(CMTask* task) : _task(task) { }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3436 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3437
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3438 G1CMOopClosure::G1CMOopClosure(G1CollectedHeap* g1h,
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3439 ConcurrentMark* cm,
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3440 CMTask* task)
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3441 : _g1h(g1h), _cm(cm), _task(task) {
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3442 assert(_ref_processor == NULL, "should be initialized to NULL");
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3443
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3444 if (G1UseConcMarkReferenceProcessing) {
3979
4dfb2df418f2 6484982: G1: process references during evacuation pauses
johnc
parents: 3977
diff changeset
3445 _ref_processor = g1h->ref_processor_cm();
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3446 assert(_ref_processor != NULL, "should not be NULL");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3447 }
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3448 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3449
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3450 void CMTask::setup_for_region(HeapRegion* hr) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3451 // Separated the asserts so that we know which one fires.
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3452 assert(hr != NULL,
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3453 "claim_region() should have filtered out continues humongous regions");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3454 assert(!hr->continuesHumongous(),
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3455 "claim_region() should have filtered out continues humongous regions");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3456
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3457 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3458 gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3459 _worker_id, p2i(hr));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3460 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3461
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3462 _curr_region = hr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3463 _finger = hr->bottom();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3464 update_region_limit();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3465 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3466
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3467 void CMTask::update_region_limit() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3468 HeapRegion* hr = _curr_region;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3469 HeapWord* bottom = hr->bottom();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3470 HeapWord* limit = hr->next_top_at_mark_start();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3471
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3472 if (limit == bottom) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3473 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3474 gclog_or_tty->print_cr("[%u] found an empty region "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3475 "["PTR_FORMAT", "PTR_FORMAT")",
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3476 _worker_id, p2i(bottom), p2i(limit));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3477 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3478 // The region was collected underneath our feet.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3479 // We set the finger to bottom to ensure that the bitmap
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3480 // iteration that will follow this will not do anything.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3481 // (this is not a condition that holds when we set the region up,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3482 // as the region is not supposed to be empty in the first place)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3483 _finger = bottom;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3484 } else if (limit >= _region_limit) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3485 assert(limit >= _finger, "peace of mind");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3486 } else {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3487 assert(limit < _region_limit, "only way to get here");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3488 // This can happen under some pretty unusual circumstances. An
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3489 // evacuation pause empties the region underneath our feet (NTAMS
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3490 // at bottom). We then do some allocation in the region (NTAMS
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3491 // stays at bottom), followed by the region being used as a GC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3492 // alloc region (NTAMS will move to top() and the objects
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3493 // originally below it will be grayed). All objects now marked in
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3494 // the region are explicitly grayed, if below the global finger,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3495 // and we do not need in fact to scan anything else. So, we simply
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3496 // set _finger to be limit to ensure that the bitmap iteration
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3497 // doesn't do anything.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3498 _finger = limit;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3499 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3500
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3501 _region_limit = limit;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3502 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3503
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3504 void CMTask::giveup_current_region() {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3505 assert(_curr_region != NULL, "invariant");
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3506 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3507 gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3508 _worker_id, p2i(_curr_region));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3509 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3510 clear_region_fields();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3511 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3512
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3513 void CMTask::clear_region_fields() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3514 // Values for these three fields that indicate that we're not
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3515 // holding on to a region.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3516 _curr_region = NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3517 _finger = NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3518 _region_limit = NULL;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3519 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3520
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3521 void CMTask::set_cm_oop_closure(G1CMOopClosure* cm_oop_closure) {
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3522 if (cm_oop_closure == NULL) {
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3523 assert(_cm_oop_closure != NULL, "invariant");
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3524 } else {
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3525 assert(_cm_oop_closure == NULL, "invariant");
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3526 }
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3527 _cm_oop_closure = cm_oop_closure;
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3528 }
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
3529
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3530 void CMTask::reset(CMBitMap* nextMarkBitMap) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3531 guarantee(nextMarkBitMap != NULL, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3532
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3533 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3534 gclog_or_tty->print_cr("[%u] resetting", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3535 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3536
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3537 _nextMarkBitMap = nextMarkBitMap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3538 clear_region_fields();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3539
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3540 _calls = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3541 _elapsed_time_ms = 0.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3542 _termination_time_ms = 0.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3543 _termination_start_time_ms = 0.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3544
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3545 #if _MARKING_STATS_
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3546 _local_pushes = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3547 _local_pops = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3548 _local_max_size = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3549 _objs_scanned = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3550 _global_pushes = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3551 _global_pops = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3552 _global_max_size = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3553 _global_transfers_to = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3554 _global_transfers_from = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3555 _regions_claimed = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3556 _objs_found_on_bitmap = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3557 _satb_buffers_processed = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3558 _steal_attempts = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3559 _steals = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3560 _aborted = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3561 _aborted_overflow = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3562 _aborted_cm_aborted = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3563 _aborted_yield = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3564 _aborted_timed_out = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3565 _aborted_satb = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3566 _aborted_termination = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3567 #endif // _MARKING_STATS_
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3568 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3569
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3570 bool CMTask::should_exit_termination() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3571 regular_clock_call();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3572 // This is called when we are in the termination protocol. We should
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3573 // quit if, for some reason, this task wants to abort or the global
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3574 // stack is not empty (this means that we can get work from it).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3575 return !_cm->mark_stack_empty() || has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3576 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3577
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3578 void CMTask::reached_limit() {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3579 assert(_words_scanned >= _words_scanned_limit ||
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3580 _refs_reached >= _refs_reached_limit ,
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3581 "shouldn't have been called otherwise");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3582 regular_clock_call();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3583 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3584
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3585 void CMTask::regular_clock_call() {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3586 if (has_aborted()) return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3587
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3588 // First, we need to recalculate the words scanned and refs reached
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3589 // limits for the next clock call.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3590 recalculate_limits();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3591
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3592 // During the regular clock call we do the following
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3593
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3594 // (1) If an overflow has been flagged, then we abort.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3595 if (_cm->has_overflown()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3596 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3597 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3598 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3599
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3600 // If we are not concurrent (i.e. we're doing remark) we don't need
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3601 // to check anything else. The other steps are only needed during
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3602 // the concurrent marking phase.
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3603 if (!concurrent()) return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3604
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3605 // (2) If marking has been aborted for Full GC, then we also abort.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3606 if (_cm->has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3607 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3608 statsOnly( ++_aborted_cm_aborted );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3609 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3610 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3611
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3612 double curr_time_ms = os::elapsedVTime() * 1000.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3613
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3614 // (3) If marking stats are enabled, then we update the step history.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3615 #if _MARKING_STATS_
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3616 if (_words_scanned >= _words_scanned_limit) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3617 ++_clock_due_to_scanning;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3618 }
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3619 if (_refs_reached >= _refs_reached_limit) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3620 ++_clock_due_to_marking;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3621 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3622
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3623 double last_interval_ms = curr_time_ms - _interval_start_time_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3624 _interval_start_time_ms = curr_time_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3625 _all_clock_intervals_ms.add(last_interval_ms);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3626
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3627 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3628 gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, "
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3629 "scanned = %d%s, refs reached = %d%s",
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3630 _worker_id, last_interval_ms,
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3631 _words_scanned,
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3632 (_words_scanned >= _words_scanned_limit) ? " (*)" : "",
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3633 _refs_reached,
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3634 (_refs_reached >= _refs_reached_limit) ? " (*)" : "");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3635 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3636 #endif // _MARKING_STATS_
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3637
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3638 // (4) We check whether we should yield. If we have to, then we abort.
20192
581e70386ec9 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 20190
diff changeset
3639 if (SuspendibleThreadSet::should_yield()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3640 // We should yield. To do this we abort the task. The caller is
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3641 // responsible for yielding.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3642 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3643 statsOnly( ++_aborted_yield );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3644 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3645 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3646
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3647 // (5) We check whether we've reached our time quota. If we have,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3648 // then we abort.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3649 double elapsed_time_ms = curr_time_ms - _start_time_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3650 if (elapsed_time_ms > _time_target_ms) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3651 set_has_aborted();
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
3652 _has_timed_out = true;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3653 statsOnly( ++_aborted_timed_out );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3654 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3655 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3656
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3657 // (6) Finally, we check whether there are enough completed STAB
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3658 // buffers available for processing. If there are, we abort.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3659 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3660 if (!_draining_satb_buffers && satb_mq_set.process_completed_buffers()) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3661 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3662 gclog_or_tty->print_cr("[%u] aborting to deal with pending SATB buffers",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3663 _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3664 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3665 // we do need to process SATB buffers, we'll abort and restart
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3666 // the marking task to do so
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3667 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3668 statsOnly( ++_aborted_satb );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3669 return;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3670 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3671 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3672
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3673 void CMTask::recalculate_limits() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3674 _real_words_scanned_limit = _words_scanned + words_scanned_period;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3675 _words_scanned_limit = _real_words_scanned_limit;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3676
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3677 _real_refs_reached_limit = _refs_reached + refs_reached_period;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3678 _refs_reached_limit = _real_refs_reached_limit;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3679 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3680
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3681 void CMTask::decrease_limits() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3682 // This is called when we believe that we're going to do an infrequent
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3683 // operation which will increase the per byte scanned cost (i.e. move
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3684 // entries to/from the global stack). It basically tries to decrease the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3685 // scanning limit so that the clock is called earlier.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3686
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3687 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3688 gclog_or_tty->print_cr("[%u] decreasing limits", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3689 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3690
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3691 _words_scanned_limit = _real_words_scanned_limit -
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3692 3 * words_scanned_period / 4;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3693 _refs_reached_limit = _real_refs_reached_limit -
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3694 3 * refs_reached_period / 4;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3695 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3696
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3697 void CMTask::move_entries_to_global_stack() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3698 // local array where we'll store the entries that will be popped
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3699 // from the local queue
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3700 oop buffer[global_stack_transfer_size];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3701
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3702 int n = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3703 oop obj;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3704 while (n < global_stack_transfer_size && _task_queue->pop_local(obj)) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3705 buffer[n] = obj;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3706 ++n;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3707 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3708
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3709 if (n > 0) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3710 // we popped at least one entry from the local queue
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3711
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3712 statsOnly( ++_global_transfers_to; _local_pops += n );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3713
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3714 if (!_cm->mark_stack_push(buffer, n)) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3715 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3716 gclog_or_tty->print_cr("[%u] aborting due to global stack overflow",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3717 _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3718 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3719 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3720 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3721 // the transfer was successful
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3722
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3723 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3724 gclog_or_tty->print_cr("[%u] pushed %d entries to the global stack",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3725 _worker_id, n);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3726 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3727 statsOnly( int tmp_size = _cm->mark_stack_size();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3728 if (tmp_size > _global_max_size) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3729 _global_max_size = tmp_size;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3730 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3731 _global_pushes += n );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3732 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3733 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3734
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3735 // this operation was quite expensive, so decrease the limits
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3736 decrease_limits();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3737 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3738
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3739 void CMTask::get_entries_from_global_stack() {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3740 // local array where we'll store the entries that will be popped
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3741 // from the global stack.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3742 oop buffer[global_stack_transfer_size];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3743 int n;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3744 _cm->mark_stack_pop(buffer, global_stack_transfer_size, &n);
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3745 assert(n <= global_stack_transfer_size,
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3746 "we should not pop more than the given limit");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3747 if (n > 0) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3748 // yes, we did actually pop at least one entry
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3749
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3750 statsOnly( ++_global_transfers_from; _global_pops += n );
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3751 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3752 gclog_or_tty->print_cr("[%u] popped %d entries from the global stack",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3753 _worker_id, n);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3754 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3755 for (int i = 0; i < n; ++i) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3756 bool success = _task_queue->push(buffer[i]);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3757 // We only call this when the local queue is empty or under a
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3758 // given target limit. So, we do not expect this push to fail.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3759 assert(success, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3760 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3761
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3762 statsOnly( int tmp_size = _task_queue->size();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3763 if (tmp_size > _local_max_size) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3764 _local_max_size = tmp_size;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3765 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3766 _local_pushes += n );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3767 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3768
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3769 // this operation was quite expensive, so decrease the limits
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3770 decrease_limits();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3771 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3772
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3773 void CMTask::drain_local_queue(bool partially) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3774 if (has_aborted()) return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3775
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3776 // Decide what the target size is, depending whether we're going to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3777 // drain it partially (so that other tasks can steal if they run out
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3778 // of things to do) or totally (at the very end).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3779 size_t target_size;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3780 if (partially) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3781 target_size = MIN2((size_t)_task_queue->max_elems()/3, GCDrainStackTargetSize);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3782 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3783 target_size = 0;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3784 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3785
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3786 if (_task_queue->size() > target_size) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3787 if (_cm->verbose_high()) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3788 gclog_or_tty->print_cr("[%u] draining local queue, target size = " SIZE_FORMAT,
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3789 _worker_id, target_size);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3790 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3791
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3792 oop obj;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3793 bool ret = _task_queue->pop_local(obj);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3794 while (ret) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3795 statsOnly( ++_local_pops );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3796
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3797 if (_cm->verbose_high()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3798 gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3799 p2i((void*) obj));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3800 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3801
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3802 assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
2361
1216415d8e35 7014923: G1: code cleanup
tonyp
parents: 2177
diff changeset
3803 assert(!_g1h->is_on_master_free_list(
2152
0fa27f37d4d4 6977804: G1: remove the zero-filling thread
tonyp
parents: 2149
diff changeset
3804 _g1h->heap_region_containing((HeapWord*) obj)), "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3805
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3806 scan_object(obj);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3807
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3808 if (_task_queue->size() <= target_size || has_aborted()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3809 ret = false;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3810 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3811 ret = _task_queue->pop_local(obj);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3812 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3813 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3814
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3815 if (_cm->verbose_high()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3816 gclog_or_tty->print_cr("[%u] drained local queue, size = %d",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3817 _worker_id, _task_queue->size());
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3818 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3819 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3820 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3821
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3822 void CMTask::drain_global_stack(bool partially) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3823 if (has_aborted()) return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3824
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3825 // We have a policy to drain the local queue before we attempt to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3826 // drain the global stack.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3827 assert(partially || _task_queue->size() == 0, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3828
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3829 // Decide what the target size is, depending whether we're going to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3830 // drain it partially (so that other tasks can steal if they run out
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3831 // of things to do) or totally (at the very end). Notice that,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3832 // because we move entries from the global stack in chunks or
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3833 // because another task might be doing the same, we might in fact
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3834 // drop below the target. But, this is not a problem.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3835 size_t target_size;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3836 if (partially) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3837 target_size = _cm->partial_mark_stack_size_target();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3838 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3839 target_size = 0;
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3840 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3841
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3842 if (_cm->mark_stack_size() > target_size) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3843 if (_cm->verbose_low()) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3844 gclog_or_tty->print_cr("[%u] draining global_stack, target size " SIZE_FORMAT,
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3845 _worker_id, target_size);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3846 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3847
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3848 while (!has_aborted() && _cm->mark_stack_size() > target_size) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3849 get_entries_from_global_stack();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3850 drain_local_queue(partially);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3851 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3852
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3853 if (_cm->verbose_low()) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
3854 gclog_or_tty->print_cr("[%u] drained global stack, size = " SIZE_FORMAT,
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3855 _worker_id, _cm->mark_stack_size());
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3856 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3857 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3858 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3859
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3860 // SATB Queue has several assumptions on whether to call the par or
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3861 // non-par versions of the methods. this is why some of the code is
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3862 // replicated. We should really get rid of the single-threaded version
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3863 // of the code to simplify things.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3864 void CMTask::drain_satb_buffers() {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3865 if (has_aborted()) return;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3866
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3867 // We set this so that the regular clock knows that we're in the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3868 // middle of draining buffers and doesn't set the abort flag when it
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3869 // notices that SATB buffers are available for draining. It'd be
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3870 // very counter productive if it did that. :-)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3871 _draining_satb_buffers = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3872
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3873 CMObjectClosure oc(this);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3874 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3875 if (G1CollectedHeap::use_parallel_gc_threads()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3876 satb_mq_set.set_par_closure(_worker_id, &oc);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3877 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3878 satb_mq_set.set_closure(&oc);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3879 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3880
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3881 // This keeps claiming and applying the closure to completed buffers
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3882 // until we run out of buffers or we need to abort.
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1719
diff changeset
3883 if (G1CollectedHeap::use_parallel_gc_threads()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3884 while (!has_aborted() &&
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3885 satb_mq_set.par_apply_closure_to_completed_buffer(_worker_id)) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3886 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3887 gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3888 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3889 statsOnly( ++_satb_buffers_processed );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3890 regular_clock_call();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3891 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3892 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3893 while (!has_aborted() &&
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3894 satb_mq_set.apply_closure_to_completed_buffer()) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3895 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3896 gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3897 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3898 statsOnly( ++_satb_buffers_processed );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3899 regular_clock_call();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3900 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3901 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3902
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3903 if (!concurrent() && !has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3904 // We should only do this during remark.
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3905 if (G1CollectedHeap::use_parallel_gc_threads()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3906 satb_mq_set.par_iterate_closure_all_threads(_worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3907 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3908 satb_mq_set.iterate_closure_all_threads();
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3909 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3910 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3911
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3912 _draining_satb_buffers = false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3913
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3914 assert(has_aborted() ||
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3915 concurrent() ||
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
3916 satb_mq_set.completed_buffers_num() == 0, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3917
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3918 if (G1CollectedHeap::use_parallel_gc_threads()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3919 satb_mq_set.set_par_closure(_worker_id, NULL);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3920 } else {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3921 satb_mq_set.set_closure(NULL);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
3922 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3923
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3924 // again, this was a potentially expensive operation, decrease the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3925 // limits to get the regular clock call early
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3926 decrease_limits();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3927 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3928
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3929 void CMTask::print_stats() {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3930 gclog_or_tty->print_cr("Marking Stats, task = %u, calls = %d",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
3931 _worker_id, _calls);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3932 gclog_or_tty->print_cr(" Elapsed time = %1.2lfms, Termination time = %1.2lfms",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3933 _elapsed_time_ms, _termination_time_ms);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3934 gclog_or_tty->print_cr(" Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3935 _step_times_ms.num(), _step_times_ms.avg(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3936 _step_times_ms.sd());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3937 gclog_or_tty->print_cr(" max = %1.2lfms, total = %1.2lfms",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3938 _step_times_ms.maximum(), _step_times_ms.sum());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3939
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3940 #if _MARKING_STATS_
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3941 gclog_or_tty->print_cr(" Clock Intervals (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3942 _all_clock_intervals_ms.num(), _all_clock_intervals_ms.avg(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3943 _all_clock_intervals_ms.sd());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3944 gclog_or_tty->print_cr(" max = %1.2lfms, total = %1.2lfms",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3945 _all_clock_intervals_ms.maximum(),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3946 _all_clock_intervals_ms.sum());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3947 gclog_or_tty->print_cr(" Clock Causes (cum): scanning = %d, marking = %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3948 _clock_due_to_scanning, _clock_due_to_marking);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3949 gclog_or_tty->print_cr(" Objects: scanned = %d, found on the bitmap = %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3950 _objs_scanned, _objs_found_on_bitmap);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3951 gclog_or_tty->print_cr(" Local Queue: pushes = %d, pops = %d, max size = %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3952 _local_pushes, _local_pops, _local_max_size);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3953 gclog_or_tty->print_cr(" Global Stack: pushes = %d, pops = %d, max size = %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3954 _global_pushes, _global_pops, _global_max_size);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3955 gclog_or_tty->print_cr(" transfers to = %d, transfers from = %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3956 _global_transfers_to,_global_transfers_from);
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
3957 gclog_or_tty->print_cr(" Regions: claimed = %d", _regions_claimed);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3958 gclog_or_tty->print_cr(" SATB buffers: processed = %d", _satb_buffers_processed);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3959 gclog_or_tty->print_cr(" Steals: attempts = %d, successes = %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3960 _steal_attempts, _steals);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3961 gclog_or_tty->print_cr(" Aborted: %d, due to", _aborted);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3962 gclog_or_tty->print_cr(" overflow: %d, global abort: %d, yield: %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3963 _aborted_overflow, _aborted_cm_aborted, _aborted_yield);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3964 gclog_or_tty->print_cr(" time out: %d, SATB: %d, termination: %d",
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3965 _aborted_timed_out, _aborted_satb, _aborted_termination);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3966 #endif // _MARKING_STATS_
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3967 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3968
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3969 /*****************************************************************************
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3970
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
3971 The do_marking_step(time_target_ms, ...) method is the building
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
3972 block of the parallel marking framework. It can be called in parallel
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3973 with other invocations of do_marking_step() on different tasks
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3974 (but only one per task, obviously) and concurrently with the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3975 mutator threads, or during remark, hence it eliminates the need
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3976 for two versions of the code. When called during remark, it will
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3977 pick up from where the task left off during the concurrent marking
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3978 phase. Interestingly, tasks are also claimable during evacuation
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3979 pauses too, since do_marking_step() ensures that it aborts before
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3980 it needs to yield.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3981
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
3982 The data structures that it uses to do marking work are the
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3983 following:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3984
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3985 (1) Marking Bitmap. If there are gray objects that appear only
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3986 on the bitmap (this happens either when dealing with an overflow
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3987 or when the initial marking phase has simply marked the roots
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3988 and didn't push them on the stack), then tasks claim heap
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3989 regions whose bitmap they then scan to find gray objects. A
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3990 global finger indicates where the end of the last claimed region
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3991 is. A local finger indicates how far into the region a task has
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3992 scanned. The two fingers are used to determine how to gray an
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3993 object (i.e. whether simply marking it is OK, as it will be
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3994 visited by a task in the future, or whether it needs to be also
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3995 pushed on a stack).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3996
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3997 (2) Local Queue. The local queue of the task which is accessed
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3998 reasonably efficiently by the task. Other tasks can steal from
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
3999 it when they run out of work. Throughout the marking phase, a
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4000 task attempts to keep its local queue short but not totally
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4001 empty, so that entries are available for stealing by other
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4002 tasks. Only when there is no more work, a task will totally
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4003 drain its local queue.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4004
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4005 (3) Global Mark Stack. This handles local queue overflow. During
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4006 marking only sets of entries are moved between it and the local
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4007 queues, as access to it requires a mutex and more fine-grain
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4008 interaction with it which might cause contention. If it
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4009 overflows, then the marking phase should restart and iterate
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4010 over the bitmap to identify gray objects. Throughout the marking
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4011 phase, tasks attempt to keep the global mark stack at a small
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4012 length but not totally empty, so that entries are available for
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4013 popping by other tasks. Only when there is no more work, tasks
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4014 will totally drain the global mark stack.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4015
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4016 (4) SATB Buffer Queue. This is where completed SATB buffers are
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4017 made available. Buffers are regularly removed from this queue
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4018 and scanned for roots, so that the queue doesn't get too
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4019 long. During remark, all completed buffers are processed, as
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4020 well as the filled in parts of any uncompleted buffers.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4021
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4022 The do_marking_step() method tries to abort when the time target
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4023 has been reached. There are a few other cases when the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4024 do_marking_step() method also aborts:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4025
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4026 (1) When the marking phase has been aborted (after a Full GC).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4027
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4028 (2) When a global overflow (on the global stack) has been
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4029 triggered. Before the task aborts, it will actually sync up with
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4030 the other tasks to ensure that all the marking data structures
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
4031 (local queues, stacks, fingers etc.) are re-initialized so that
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4032 when do_marking_step() completes, the marking phase can
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4033 immediately restart.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4034
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4035 (3) When enough completed SATB buffers are available. The
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4036 do_marking_step() method only tries to drain SATB buffers right
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4037 at the beginning. So, if enough buffers are available, the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4038 marking step aborts and the SATB buffers are processed at
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4039 the beginning of the next invocation.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4040
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4041 (4) To yield. when we have to yield then we abort and yield
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4042 right at the end of do_marking_step(). This saves us from a lot
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4043 of hassle as, by yielding we might allow a Full GC. If this
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4044 happens then objects will be compacted underneath our feet, the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4045 heap might shrink, etc. We save checking for this by just
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4046 aborting and doing the yield right at the end.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4047
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4048 From the above it follows that the do_marking_step() method should
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4049 be called in a loop (or, otherwise, regularly) until it completes.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4050
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4051 If a marking step completes without its has_aborted() flag being
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4052 true, it means it has completed the current marking phase (and
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4053 also all other marking tasks have done so and have all synced up).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4054
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4055 A method called regular_clock_call() is invoked "regularly" (in
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4056 sub ms intervals) throughout marking. It is this clock method that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4057 checks all the abort conditions which were mentioned above and
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4058 decides when the task should abort. A work-based scheme is used to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4059 trigger this clock method: when the number of object words the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4060 marking phase has scanned or the number of references the marking
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4061 phase has visited reach a given limit. Additional invocations to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4062 the method clock have been planted in a few other strategic places
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4063 too. The initial reason for the clock method was to avoid calling
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4064 vtime too regularly, as it is quite expensive. So, once it was in
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4065 place, it was natural to piggy-back all the other conditions on it
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4066 too and not constantly check them throughout the code.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4067
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4068 If do_termination is true then do_marking_step will enter its
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4069 termination protocol.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4070
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4071 The value of is_serial must be true when do_marking_step is being
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4072 called serially (i.e. by the VMThread) and do_marking_step should
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4073 skip any synchronization in the termination and overflow code.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4074 Examples include the serial remark code and the serial reference
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4075 processing closures.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4076
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4077 The value of is_serial must be false when do_marking_step is
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4078 being called by any of the worker threads in a work gang.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4079 Examples include the concurrent marking code (CMMarkingTask),
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4080 the MT remark code, and the MT reference processing closures.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4081
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4082 *****************************************************************************/
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4083
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
4084 void CMTask::do_marking_step(double time_target_ms,
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4085 bool do_termination,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4086 bool is_serial) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4087 assert(time_target_ms >= 1.0, "minimum granularity is 1ms");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4088 assert(concurrent() == _cm->concurrent(), "they should be the same");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4089
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4090 G1CollectorPolicy* g1_policy = _g1h->g1_policy();
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4091 assert(_task_queues != NULL, "invariant");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4092 assert(_task_queue != NULL, "invariant");
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4093 assert(_task_queues->queue(_worker_id) == _task_queue, "invariant");
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4094
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4095 assert(!_claimed,
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4096 "only one thread should claim this task at any one time");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4097
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4098 // OK, this doesn't safeguard again all possible scenarios, as it is
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4099 // possible for two threads to set the _claimed flag at the same
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4100 // time. But it is only for debugging purposes anyway and it will
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4101 // catch most problems.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4102 _claimed = true;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4103
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4104 _start_time_ms = os::elapsedVTime() * 1000.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4105 statsOnly( _interval_start_time_ms = _start_time_ms );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4106
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4107 // If do_stealing is true then do_marking_step will attempt to
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4108 // steal work from the other CMTasks. It only makes sense to
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4109 // enable stealing when the termination protocol is enabled
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4110 // and do_marking_step() is not being called serially.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4111 bool do_stealing = do_termination && !is_serial;
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4112
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4113 double diff_prediction_ms =
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4114 g1_policy->get_new_prediction(&_marking_step_diffs_ms);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4115 _time_target_ms = time_target_ms - diff_prediction_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4116
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4117 // set up the variables that are used in the work-based scheme to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4118 // call the regular clock method
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4119 _words_scanned = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4120 _refs_reached = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4121 recalculate_limits();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4122
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4123 // clear all flags
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4124 clear_has_aborted();
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
4125 _has_timed_out = false;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4126 _draining_satb_buffers = false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4127
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4128 ++_calls;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4129
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4130 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4131 gclog_or_tty->print_cr("[%u] >>>>>>>>>> START, call = %d, "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4132 "target = %1.2lfms >>>>>>>>>>",
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4133 _worker_id, _calls, _time_target_ms);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4134 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4135
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4136 // Set up the bitmap and oop closures. Anything that uses them is
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4137 // eventually called from this method, so it is OK to allocate these
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4138 // statically.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4139 CMBitMapClosure bitmap_closure(this, _cm, _nextMarkBitMap);
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
4140 G1CMOopClosure cm_oop_closure(_g1h, _cm, this);
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
4141 set_cm_oop_closure(&cm_oop_closure);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4142
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4143 if (_cm->has_overflown()) {
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4144 // This can happen if the mark stack overflows during a GC pause
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4145 // and this task, after a yield point, restarts. We have to abort
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4146 // as we need to get into the overflow protocol which happens
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4147 // right at the end of this task.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4148 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4149 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4150
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4151 // First drain any available SATB buffers. After this, we will not
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4152 // look at SATB buffers before the next invocation of this method.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4153 // If enough completed SATB buffers are queued up, the regular clock
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4154 // will abort this task so that it restarts.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4155 drain_satb_buffers();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4156 // ...then partially drain the local queue and the global stack
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4157 drain_local_queue(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4158 drain_global_stack(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4159
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4160 do {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4161 if (!has_aborted() && _curr_region != NULL) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4162 // This means that we're already holding on to a region.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4163 assert(_finger != NULL, "if region is not NULL, then the finger "
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4164 "should not be NULL either");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4165
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4166 // We might have restarted this task after an evacuation pause
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4167 // which might have evacuated the region we're holding on to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4168 // underneath our feet. Let's read its limit again to make sure
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4169 // that we do not iterate over a region of the heap that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4170 // contains garbage (update_region_limit() will also move
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4171 // _finger to the start of the region if it is found empty).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4172 update_region_limit();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4173 // We will start from _finger not from the start of the region,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4174 // as we might be restarting this task after aborting half-way
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4175 // through scanning this region. In this case, _finger points to
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4176 // the address where we last found a marked object. If this is a
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4177 // fresh region, _finger points to start().
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4178 MemRegion mr = MemRegion(_finger, _region_limit);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4179
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4180 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4181 gclog_or_tty->print_cr("[%u] we're scanning part "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4182 "["PTR_FORMAT", "PTR_FORMAT") "
8039
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4183 "of region "HR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
4184 _worker_id, p2i(_finger), p2i(_region_limit),
8039
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4185 HR_FORMAT_PARAMS(_curr_region));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4186 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4187
8039
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4188 assert(!_curr_region->isHumongous() || mr.start() == _curr_region->bottom(),
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4189 "humongous regions should go around loop once only");
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4190
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4191 // Some special cases:
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4192 // If the memory region is empty, we can just give up the region.
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4193 // If the current region is humongous then we only need to check
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4194 // the bitmap for the bit associated with the start of the object,
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4195 // scan the object if it's live, and give up the region.
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4196 // Otherwise, let's iterate over the bitmap of the part of the region
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4197 // that is left.
8034
bce1ac447f6b 7052429: G1: Avoid unnecessary scanning of humongous regions during concurrent marking
johnc
parents: 8014
diff changeset
4198 // If the iteration is successful, give up the region.
8039
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4199 if (mr.is_empty()) {
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4200 giveup_current_region();
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4201 regular_clock_call();
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4202 } else if (_curr_region->isHumongous() && mr.start() == _curr_region->bottom()) {
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4203 if (_nextMarkBitMap->isMarked(mr.start())) {
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4204 // The object is marked - apply the closure
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4205 BitMap::idx_t offset = _nextMarkBitMap->heapWordToOffset(mr.start());
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4206 bitmap_closure.do_bit(offset);
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4207 }
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4208 // Even if this task aborted while scanning the humongous object
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4209 // we can (and should) give up the current region.
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4210 giveup_current_region();
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4211 regular_clock_call();
5e401ef52ec0 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 8034
diff changeset
4212 } else if (_nextMarkBitMap->iterate(&bitmap_closure, mr)) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4213 giveup_current_region();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4214 regular_clock_call();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4215 } else {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4216 assert(has_aborted(), "currently the only way to do so");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4217 // The only way to abort the bitmap iteration is to return
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4218 // false from the do_bit() method. However, inside the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4219 // do_bit() method we move the _finger to point to the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4220 // object currently being looked at. So, if we bail out, we
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4221 // have definitely set _finger to something non-null.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4222 assert(_finger != NULL, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4223
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4224 // Region iteration was actually aborted. So now _finger
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4225 // points to the address of the object we last scanned. If we
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4226 // leave it there, when we restart this task, we will rescan
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4227 // the object. It is easy to avoid this. We move the finger by
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4228 // enough to point to the next possible object header (the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4229 // bitmap knows by how much we need to move it as it knows its
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4230 // granularity).
1314
3f0549ed0c98 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 1284
diff changeset
4231 assert(_finger < _region_limit, "invariant");
8733
9def4075da6d 8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents: 8039
diff changeset
4232 HeapWord* new_finger = _nextMarkBitMap->nextObject(_finger);
1314
3f0549ed0c98 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 1284
diff changeset
4233 // Check if bitmap iteration was aborted while scanning the last object
3f0549ed0c98 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 1284
diff changeset
4234 if (new_finger >= _region_limit) {
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4235 giveup_current_region();
1314
3f0549ed0c98 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 1284
diff changeset
4236 } else {
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4237 move_finger_to(new_finger);
1314
3f0549ed0c98 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 1284
diff changeset
4238 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4239 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4240 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4241 // At this point we have either completed iterating over the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4242 // region we were holding on to, or we have aborted.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4243
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4244 // We then partially drain the local queue and the global stack.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4245 // (Do we really need this?)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4246 drain_local_queue(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4247 drain_global_stack(true);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4248
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4249 // Read the note on the claim_region() method on why it might
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4250 // return NULL with potentially more regions available for
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4251 // claiming and why we have to check out_of_regions() to determine
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4252 // whether we're done or not.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4253 while (!has_aborted() && _curr_region == NULL && !_cm->out_of_regions()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4254 // We are going to try to claim a new region. We should have
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4255 // given up on the previous one.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4256 // Separated the asserts so that we know which one fires.
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4257 assert(_curr_region == NULL, "invariant");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4258 assert(_finger == NULL, "invariant");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4259 assert(_region_limit == NULL, "invariant");
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4260 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4261 gclog_or_tty->print_cr("[%u] trying to claim a new region", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4262 }
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4263 HeapRegion* claimed_region = _cm->claim_region(_worker_id);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4264 if (claimed_region != NULL) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4265 // Yes, we managed to claim one
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4266 statsOnly( ++_regions_claimed );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4267
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4268 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4269 gclog_or_tty->print_cr("[%u] we successfully claimed "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4270 "region "PTR_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
4271 _worker_id, p2i(claimed_region));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4272 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4273
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4274 setup_for_region(claimed_region);
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4275 assert(_curr_region == claimed_region, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4276 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4277 // It is important to call the regular clock here. It might take
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4278 // a while to claim a region if, for example, we hit a large
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4279 // block of empty regions. So we need to call the regular clock
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4280 // method once round the loop to make sure it's called
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4281 // frequently enough.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4282 regular_clock_call();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4283 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4284
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4285 if (!has_aborted() && _curr_region == NULL) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4286 assert(_cm->out_of_regions(),
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4287 "at this point we should be out of regions");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4288 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4289 } while ( _curr_region != NULL && !has_aborted());
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4290
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4291 if (!has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4292 // We cannot check whether the global stack is empty, since other
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4293 // tasks might be pushing objects to it concurrently.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4294 assert(_cm->out_of_regions(),
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4295 "at this point we should be out of regions");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4296
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4297 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4298 gclog_or_tty->print_cr("[%u] all regions claimed", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4299 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4300
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4301 // Try to reduce the number of available SATB buffers so that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4302 // remark has less work to do.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4303 drain_satb_buffers();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4304 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4305
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4306 // Since we've done everything else, we can now totally drain the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4307 // local queue and global stack.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4308 drain_local_queue(false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4309 drain_global_stack(false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4310
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4311 // Attempt at work stealing from other task's queues.
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
4312 if (do_stealing && !has_aborted()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4313 // We have not aborted. This means that we have finished all that
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4314 // we could. Let's try to do some stealing...
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4315
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4316 // We cannot check whether the global stack is empty, since other
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4317 // tasks might be pushing objects to it concurrently.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4318 assert(_cm->out_of_regions() && _task_queue->size() == 0,
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4319 "only way to reach here");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4320
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4321 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4322 gclog_or_tty->print_cr("[%u] starting to steal", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4323 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4324
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4325 while (!has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4326 oop obj;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4327 statsOnly( ++_steal_attempts );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4328
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4329 if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4330 if (_cm->verbose_medium()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4331 gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
4332 _worker_id, p2i((void*) obj));
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4333 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4334
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4335 statsOnly( ++_steals );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4336
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4337 assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4338 "any stolen object should be marked");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4339 scan_object(obj);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4340
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4341 // And since we're towards the end, let's totally drain the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4342 // local queue and global stack.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4343 drain_local_queue(false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4344 drain_global_stack(false);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4345 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4346 break;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4347 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4348 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4349 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4350
3316
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4351 // If we are about to wrap up and go into termination, check if we
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4352 // should raise the overflow flag.
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4353 if (do_termination && !has_aborted()) {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4354 if (_cm->force_overflow()->should_force()) {
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4355 _cm->set_has_overflown();
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4356 regular_clock_call();
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4357 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4358 }
cd8e33b2a8ad 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 2436
diff changeset
4359
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4360 // We still haven't aborted. Now, let's try to get into the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4361 // termination protocol.
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
4362 if (do_termination && !has_aborted()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4363 // We cannot check whether the global stack is empty, since other
5988
2a0172480595 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 4837
diff changeset
4364 // tasks might be concurrently pushing objects on it.
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4365 // Separated the asserts so that we know which one fires.
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4366 assert(_cm->out_of_regions(), "only way to reach here");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4367 assert(_task_queue->size() == 0, "only way to reach here");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4368
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4369 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4370 gclog_or_tty->print_cr("[%u] starting termination protocol", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4371 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4372
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4373 _termination_start_time_ms = os::elapsedVTime() * 1000.0;
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4374
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4375 // The CMTask class also extends the TerminatorTerminator class,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4376 // hence its should_exit_termination() method will also decide
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4377 // whether to exit the termination protocol or not.
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4378 bool finished = (is_serial ||
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4379 _cm->terminator()->offer_termination(this));
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4380 double termination_end_time_ms = os::elapsedVTime() * 1000.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4381 _termination_time_ms +=
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4382 termination_end_time_ms - _termination_start_time_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4383
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4384 if (finished) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4385 // We're all done.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4386
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4387 if (_worker_id == 0) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4388 // let's allow task 0 to do this
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4389 if (concurrent()) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4390 assert(_cm->concurrent_marking_in_progress(), "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4391 // we need to set this to false before the next
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4392 // safepoint. This way we ensure that the marking phase
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4393 // doesn't observe any more heap expansions.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4394 _cm->clear_concurrent_marking_in_progress();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4395 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4396 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4397
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4398 // We can now guarantee that the global stack is empty, since
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4399 // all other tasks have finished. We separated the guarantees so
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4400 // that, if a condition is false, we can immediately find out
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4401 // which one.
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4402 guarantee(_cm->out_of_regions(), "only way to reach here");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4403 guarantee(_cm->mark_stack_empty(), "only way to reach here");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4404 guarantee(_task_queue->size() == 0, "only way to reach here");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4405 guarantee(!_cm->has_overflown(), "only way to reach here");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4406 guarantee(!_cm->mark_stack_overflow(), "only way to reach here");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4407
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4408 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4409 gclog_or_tty->print_cr("[%u] all tasks terminated", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4410 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4411 } else {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4412 // Apparently there's more work to do. Let's abort this task. It
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4413 // will restart it and we can hopefully find more things to do.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4414
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4415 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4416 gclog_or_tty->print_cr("[%u] apparently there is more work to do",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4417 _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4418 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4419
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4420 set_has_aborted();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4421 statsOnly( ++_aborted_termination );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4422 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4423 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4424
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4425 // Mainly for debugging purposes to make sure that a pointer to the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4426 // closure which was statically allocated in this frame doesn't
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4427 // escape it by accident.
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
4428 set_cm_oop_closure(NULL);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4429 double end_time_ms = os::elapsedVTime() * 1000.0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4430 double elapsed_time_ms = end_time_ms - _start_time_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4431 // Update the step history.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4432 _step_times_ms.add(elapsed_time_ms);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4433
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4434 if (has_aborted()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4435 // The task was aborted for some reason.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4436
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4437 statsOnly( ++_aborted );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4438
2174
234761c55641 6608385: G1: need to support parallel reference processing
johnc
parents: 2152
diff changeset
4439 if (_has_timed_out) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4440 double diff_ms = elapsed_time_ms - _time_target_ms;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4441 // Keep statistics of how well we did with respect to hitting
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4442 // our target only if we actually timed out (if we aborted for
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4443 // other reasons, then the results might get skewed).
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4444 _marking_step_diffs_ms.add(diff_ms);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4445 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4446
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4447 if (_cm->has_overflown()) {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4448 // This is the interesting one. We aborted because a global
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4449 // overflow was raised. This means we have to restart the
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4450 // marking phase and start iterating over regions. However, in
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4451 // order to do this we have to make sure that all tasks stop
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4452 // what they are doing and re-initialise in a safe manner. We
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4453 // will achieve this with the use of two barrier sync points.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4454
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4455 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4456 gclog_or_tty->print_cr("[%u] detected overflow", _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4457 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4458
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4459 if (!is_serial) {
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4460 // We only need to enter the sync barrier if being called
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4461 // from a parallel context
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4462 _cm->enter_first_sync_barrier(_worker_id);
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4463
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4464 // When we exit this sync barrier we know that all tasks have
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4465 // stopped doing marking work. So, it's now safe to
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4466 // re-initialise our data structures. At the end of this method,
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4467 // task 0 will clear the global data structures.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4468 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4469
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4470 statsOnly( ++_aborted_overflow );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4471
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4472 // We clear the local state of this task...
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4473 clear_region_fields();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4474
8787
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4475 if (!is_serial) {
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4476 // ...and enter the second barrier.
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4477 _cm->enter_second_sync_barrier(_worker_id);
fa08949fe0cb 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 8744
diff changeset
4478 }
8788
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
4479 // At this point, if we're during the concurrent phase of
e864cc14ca75 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 8787
diff changeset
4480 // marking, everything has been re-initialized and we're
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4481 // ready to restart.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4482 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4483
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4484 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4485 gclog_or_tty->print_cr("[%u] <<<<<<<<<< ABORTING, target = %1.2lfms, "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4486 "elapsed = %1.2lfms <<<<<<<<<<",
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4487 _worker_id, _time_target_ms, elapsed_time_ms);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4488 if (_cm->has_aborted()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4489 gclog_or_tty->print_cr("[%u] ========== MARKING ABORTED ==========",
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4490 _worker_id);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4491 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4492 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4493 } else {
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4494 if (_cm->verbose_low()) {
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4495 gclog_or_tty->print_cr("[%u] <<<<<<<<<< FINISHED, target = %1.2lfms, "
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4496 "elapsed = %1.2lfms <<<<<<<<<<",
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4497 _worker_id, _time_target_ms, elapsed_time_ms);
3776
23d434c6290d 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 3772
diff changeset
4498 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4499 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4500
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4501 _claimed = false;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4502 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4503
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4504 CMTask::CMTask(uint worker_id,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4505 ConcurrentMark* cm,
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
4506 size_t* marked_bytes,
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
4507 BitMap* card_bm,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4508 CMTaskQueue* task_queue,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4509 CMTaskQueueSet* task_queues)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4510 : _g1h(G1CollectedHeap::heap()),
6862
8a5ea0a9ccc4 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 6812
diff changeset
4511 _worker_id(worker_id), _cm(cm),
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4512 _claimed(false),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4513 _nextMarkBitMap(NULL), _hash_seed(17),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4514 _task_queue(task_queue),
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4515 _task_queues(task_queues),
3771
842b840e67db 7046558: G1: concurrent marking optimizations
tonyp
parents: 3378
diff changeset
4516 _cm_oop_closure(NULL),
4836
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
4517 _marked_bytes_array(marked_bytes),
d30fa85f9994 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 4830
diff changeset
4518 _card_bm(card_bm) {
1023
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4519 guarantee(task_queue != NULL, "invariant");
11d4857fe5e1 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 1022
diff changeset
4520 guarantee(task_queues != NULL, "invariant");
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4521
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4522 statsOnly( _clock_due_to_scanning = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4523 _clock_due_to_marking = 0 );
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4524
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4525 _marking_step_diffs_ms.add(0.5);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
4526 }
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4527
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4528 // These are formatting macros that are used below to ensure
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4529 // consistent formatting. The *_H_* versions are used to format the
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4530 // header for a particular value and they should be kept consistent
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4531 // with the corresponding macro. Also note that most of the macros add
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4532 // the necessary white space (as a prefix) which makes them a bit
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4533 // easier to compose.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4534
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4535 // All the output lines are prefixed with this string to be able to
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4536 // identify them easily in a large log file.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4537 #define G1PPRL_LINE_PREFIX "###"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4538
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4539 #define G1PPRL_ADDR_BASE_FORMAT " "PTR_FORMAT"-"PTR_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4540 #ifdef _LP64
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4541 #define G1PPRL_ADDR_BASE_H_FORMAT " %37s"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4542 #else // _LP64
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4543 #define G1PPRL_ADDR_BASE_H_FORMAT " %21s"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4544 #endif // _LP64
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4545
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4546 // For per-region info
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4547 #define G1PPRL_TYPE_FORMAT " %-4s"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4548 #define G1PPRL_TYPE_H_FORMAT " %4s"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4549 #define G1PPRL_BYTE_FORMAT " "SIZE_FORMAT_W(9)
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4550 #define G1PPRL_BYTE_H_FORMAT " %9s"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4551 #define G1PPRL_DOUBLE_FORMAT " %14.1f"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4552 #define G1PPRL_DOUBLE_H_FORMAT " %14s"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4553
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4554 // For summary info
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4555 #define G1PPRL_SUM_ADDR_FORMAT(tag) " "tag":"G1PPRL_ADDR_BASE_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4556 #define G1PPRL_SUM_BYTE_FORMAT(tag) " "tag": "SIZE_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4557 #define G1PPRL_SUM_MB_FORMAT(tag) " "tag": %1.2f MB"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4558 #define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag)" / %1.2f %%"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4559
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4560 G1PrintRegionLivenessInfoClosure::
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4561 G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name)
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4562 : _out(out),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4563 _total_used_bytes(0), _total_capacity_bytes(0),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4564 _total_prev_live_bytes(0), _total_next_live_bytes(0),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4565 _hum_used_bytes(0), _hum_capacity_bytes(0),
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4566 _hum_prev_live_bytes(0), _hum_next_live_bytes(0),
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4567 _total_remset_bytes(0), _total_strong_code_roots_bytes(0) {
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4568 G1CollectedHeap* g1h = G1CollectedHeap::heap();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4569 MemRegion g1_committed = g1h->g1_committed();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4570 MemRegion g1_reserved = g1h->g1_reserved();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4571 double now = os::elapsedTime();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4572
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4573 // Print the header of the output.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4574 _out->cr();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4575 _out->print_cr(G1PPRL_LINE_PREFIX" PHASE %s @ %1.3f", phase_name, now);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4576 _out->print_cr(G1PPRL_LINE_PREFIX" HEAP"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4577 G1PPRL_SUM_ADDR_FORMAT("committed")
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4578 G1PPRL_SUM_ADDR_FORMAT("reserved")
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4579 G1PPRL_SUM_BYTE_FORMAT("region-size"),
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
4580 p2i(g1_committed.start()), p2i(g1_committed.end()),
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
4581 p2i(g1_reserved.start()), p2i(g1_reserved.end()),
3986
65a8ff39a6da 7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents: 3979
diff changeset
4582 HeapRegion::GrainBytes);
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4583 _out->print_cr(G1PPRL_LINE_PREFIX);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4584 _out->print_cr(G1PPRL_LINE_PREFIX
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4585 G1PPRL_TYPE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4586 G1PPRL_ADDR_BASE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4587 G1PPRL_BYTE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4588 G1PPRL_BYTE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4589 G1PPRL_BYTE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4590 G1PPRL_DOUBLE_H_FORMAT
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4591 G1PPRL_BYTE_H_FORMAT
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4592 G1PPRL_BYTE_H_FORMAT,
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4593 "type", "address-range",
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4594 "used", "prev-live", "next-live", "gc-eff",
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4595 "remset", "code-roots");
3977
5cc33133bc6d 7092245: G1: Wrong format specifier in G1PrintRegionLivenessInfo header output
johnc
parents: 3975
diff changeset
4596 _out->print_cr(G1PPRL_LINE_PREFIX
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4597 G1PPRL_TYPE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4598 G1PPRL_ADDR_BASE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4599 G1PPRL_BYTE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4600 G1PPRL_BYTE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4601 G1PPRL_BYTE_H_FORMAT
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4602 G1PPRL_DOUBLE_H_FORMAT
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4603 G1PPRL_BYTE_H_FORMAT
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4604 G1PPRL_BYTE_H_FORMAT,
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4605 "", "",
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4606 "(bytes)", "(bytes)", "(bytes)", "(bytes/ms)",
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4607 "(bytes)", "(bytes)");
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4608 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4609
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4610 // It takes as a parameter a reference to one of the _hum_* fields, it
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4611 // deduces the corresponding value for a region in a humongous region
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4612 // series (either the region size, or what's left if the _hum_* field
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4613 // is < the region size), and updates the _hum_* field accordingly.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4614 size_t G1PrintRegionLivenessInfoClosure::get_hum_bytes(size_t* hum_bytes) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4615 size_t bytes = 0;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4616 // The > 0 check is to deal with the prev and next live bytes which
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4617 // could be 0.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4618 if (*hum_bytes > 0) {
3986
65a8ff39a6da 7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents: 3979
diff changeset
4619 bytes = MIN2(HeapRegion::GrainBytes, *hum_bytes);
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4620 *hum_bytes -= bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4621 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4622 return bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4623 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4624
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4625 // It deduces the values for a region in a humongous region series
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4626 // from the _hum_* fields and updates those accordingly. It assumes
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4627 // that that _hum_* fields have already been set up from the "starts
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4628 // humongous" region and we visit the regions in address order.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4629 void G1PrintRegionLivenessInfoClosure::get_hum_bytes(size_t* used_bytes,
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4630 size_t* capacity_bytes,
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4631 size_t* prev_live_bytes,
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4632 size_t* next_live_bytes) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4633 assert(_hum_used_bytes > 0 && _hum_capacity_bytes > 0, "pre-condition");
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4634 *used_bytes = get_hum_bytes(&_hum_used_bytes);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4635 *capacity_bytes = get_hum_bytes(&_hum_capacity_bytes);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4636 *prev_live_bytes = get_hum_bytes(&_hum_prev_live_bytes);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4637 *next_live_bytes = get_hum_bytes(&_hum_next_live_bytes);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4638 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4639
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4640 bool G1PrintRegionLivenessInfoClosure::doHeapRegion(HeapRegion* r) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4641 const char* type = "";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4642 HeapWord* bottom = r->bottom();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4643 HeapWord* end = r->end();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4644 size_t capacity_bytes = r->capacity();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4645 size_t used_bytes = r->used();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4646 size_t prev_live_bytes = r->live_bytes();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4647 size_t next_live_bytes = r->next_live_bytes();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4648 double gc_eff = r->gc_efficiency();
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4649 size_t remset_bytes = r->rem_set()->mem_size();
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4650 size_t strong_code_roots_bytes = r->rem_set()->strong_code_roots_mem_size();
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4651
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4652 if (r->used() == 0) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4653 type = "FREE";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4654 } else if (r->is_survivor()) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4655 type = "SURV";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4656 } else if (r->is_young()) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4657 type = "EDEN";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4658 } else if (r->startsHumongous()) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4659 type = "HUMS";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4660
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4661 assert(_hum_used_bytes == 0 && _hum_capacity_bytes == 0 &&
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4662 _hum_prev_live_bytes == 0 && _hum_next_live_bytes == 0,
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4663 "they should have been zeroed after the last time we used them");
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4664 // Set up the _hum_* fields.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4665 _hum_capacity_bytes = capacity_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4666 _hum_used_bytes = used_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4667 _hum_prev_live_bytes = prev_live_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4668 _hum_next_live_bytes = next_live_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4669 get_hum_bytes(&used_bytes, &capacity_bytes,
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4670 &prev_live_bytes, &next_live_bytes);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4671 end = bottom + HeapRegion::GrainWords;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4672 } else if (r->continuesHumongous()) {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4673 type = "HUMC";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4674 get_hum_bytes(&used_bytes, &capacity_bytes,
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4675 &prev_live_bytes, &next_live_bytes);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4676 assert(end == bottom + HeapRegion::GrainWords, "invariant");
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4677 } else {
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4678 type = "OLD";
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4679 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4680
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4681 _total_used_bytes += used_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4682 _total_capacity_bytes += capacity_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4683 _total_prev_live_bytes += prev_live_bytes;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4684 _total_next_live_bytes += next_live_bytes;
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4685 _total_remset_bytes += remset_bytes;
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4686 _total_strong_code_roots_bytes += strong_code_roots_bytes;
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4687
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4688 // Print a line for this particular region.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4689 _out->print_cr(G1PPRL_LINE_PREFIX
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4690 G1PPRL_TYPE_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4691 G1PPRL_ADDR_BASE_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4692 G1PPRL_BYTE_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4693 G1PPRL_BYTE_FORMAT
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4694 G1PPRL_BYTE_FORMAT
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4695 G1PPRL_DOUBLE_FORMAT
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4696 G1PPRL_BYTE_FORMAT
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4697 G1PPRL_BYTE_FORMAT,
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 17844
diff changeset
4698 type, p2i(bottom), p2i(end),
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4699 used_bytes, prev_live_bytes, next_live_bytes, gc_eff,
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4700 remset_bytes, strong_code_roots_bytes);
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4701
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4702 return false;
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4703 }
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4704
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4705 G1PrintRegionLivenessInfoClosure::~G1PrintRegionLivenessInfoClosure() {
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4706 // add static memory usages to remembered set sizes
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4707 _total_remset_bytes += HeapRegionRemSet::fl_mem_size() + HeapRegionRemSet::static_mem_size();
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4708 // Print the footer of the output.
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4709 _out->print_cr(G1PPRL_LINE_PREFIX);
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4710 _out->print_cr(G1PPRL_LINE_PREFIX
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4711 " SUMMARY"
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4712 G1PPRL_SUM_MB_FORMAT("capacity")
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4713 G1PPRL_SUM_MB_PERC_FORMAT("used")
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4714 G1PPRL_SUM_MB_PERC_FORMAT("prev-live")
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4715 G1PPRL_SUM_MB_PERC_FORMAT("next-live")
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4716 G1PPRL_SUM_MB_FORMAT("remset")
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4717 G1PPRL_SUM_MB_FORMAT("code-roots"),
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4718 bytes_to_mb(_total_capacity_bytes),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4719 bytes_to_mb(_total_used_bytes),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4720 perc(_total_used_bytes, _total_capacity_bytes),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4721 bytes_to_mb(_total_prev_live_bytes),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4722 perc(_total_prev_live_bytes, _total_capacity_bytes),
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4723 bytes_to_mb(_total_next_live_bytes),
10290
05a17f270c7e 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 10186
diff changeset
4724 perc(_total_next_live_bytes, _total_capacity_bytes),
12080
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4725 bytes_to_mb(_total_remset_bytes),
5888334c9c24 7145569: G1: optimize nmethods scanning
johnc
parents: 10405
diff changeset
4726 bytes_to_mb(_total_strong_code_roots_bytes));
2435
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4727 _out->cr();
371bbc844bf1 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 2369
diff changeset
4728 }