author | tschatzl |
Fri, 15 Jul 2016 13:33:44 +0200 | |
changeset 39966 | 43c7f35b800e |
parent 38637 | dba1e7561542 |
child 39979 | b17e445924da |
permissions | -rw-r--r-- |
1374 | 1 |
/* |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36191
diff
changeset
|
2 |
* Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved. |
1374 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5542
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5542
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5542
diff
changeset
|
21 |
* questions. |
1374 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
27247
99db666dbe8e
8056240: Investigate increased GC remark time after class unloading changes in CRM Fuse
stefank
parents:
27149
diff
changeset
|
26 |
#include "classfile/metadataOnStackMark.hpp" |
7397 | 27 |
#include "classfile/symbolTable.hpp" |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
28 |
#include "code/codeCache.hpp" |
30764 | 29 |
#include "gc/g1/concurrentMarkThread.inline.hpp" |
30 |
#include "gc/g1/g1CollectedHeap.inline.hpp" |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
31330
diff
changeset
|
31 |
#include "gc/g1/g1CollectorState.hpp" |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
32 |
#include "gc/g1/g1ConcurrentMark.inline.hpp" |
35851
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
33 |
#include "gc/g1/g1HeapVerifier.hpp" |
30764 | 34 |
#include "gc/g1/g1OopClosures.inline.hpp" |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
35 |
#include "gc/g1/g1CardLiveData.inline.hpp" |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37474
diff
changeset
|
36 |
#include "gc/g1/g1Policy.hpp" |
30764 | 37 |
#include "gc/g1/g1StringDedup.hpp" |
38 |
#include "gc/g1/heapRegion.inline.hpp" |
|
39 |
#include "gc/g1/heapRegionRemSet.hpp" |
|
40 |
#include "gc/g1/heapRegionSet.inline.hpp" |
|
30770
5ba2d9f2084d
8080585: concurrentGCThread.hpp should not include suspendibleThreadSet.hpp
pliden
parents:
30764
diff
changeset
|
41 |
#include "gc/g1/suspendibleThreadSet.hpp" |
33107
77bf0d2069a3
8134953: Make the GC ID available in a central place
brutisso
parents:
33105
diff
changeset
|
42 |
#include "gc/shared/gcId.hpp" |
30764 | 43 |
#include "gc/shared/gcTimer.hpp" |
44 |
#include "gc/shared/gcTrace.hpp" |
|
35061 | 45 |
#include "gc/shared/gcTraceTime.inline.hpp" |
30764 | 46 |
#include "gc/shared/genOopClosures.inline.hpp" |
47 |
#include "gc/shared/referencePolicy.hpp" |
|
48 |
#include "gc/shared/strongRootsScope.hpp" |
|
49 |
#include "gc/shared/taskqueue.inline.hpp" |
|
50 |
#include "gc/shared/vmGCOperations.hpp" |
|
35061 | 51 |
#include "logging/log.hpp" |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
52 |
#include "memory/allocation.hpp" |
7397 | 53 |
#include "memory/resourceArea.hpp" |
54 |
#include "oops/oop.inline.hpp" |
|
30764 | 55 |
#include "runtime/atomic.inline.hpp" |
7397 | 56 |
#include "runtime/handles.inline.hpp" |
57 |
#include "runtime/java.hpp" |
|
24487
71ff0bd674eb
8042737: Introduce umbrella header prefetch.inline.hpp
goetz
parents:
24424
diff
changeset
|
58 |
#include "runtime/prefetch.inline.hpp" |
13195 | 59 |
#include "services/memTracker.hpp" |
38162
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
60 |
#include "utilities/growableArray.hpp" |
1374 | 61 |
|
11575
d7a2e4295dc9
7130334: G1: Change comments and error messages that refer to CMS in g1/concurrentMark.cpp/hpp
brutisso
parents:
11574
diff
changeset
|
62 |
// Concurrent marking bit map wrapper |
1374 | 63 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
64 |
G1CMBitMapRO::G1CMBitMapRO(int shifter) : |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
65 |
_bm(), |
1374 | 66 |
_shifter(shifter) { |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
67 |
_bmStartWord = 0; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
68 |
_bmWordSize = 0; |
1374 | 69 |
} |
70 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
71 |
HeapWord* G1CMBitMapRO::getNextMarkedWordAddress(const HeapWord* addr, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
72 |
const HeapWord* limit) const { |
1374 | 73 |
// First we must round addr *up* to a possible object boundary. |
74 |
addr = (HeapWord*)align_size_up((intptr_t)addr, |
|
75 |
HeapWordSize << _shifter); |
|
76 |
size_t addrOffset = heapWordToOffset(addr); |
|
34282 | 77 |
assert(limit != NULL, "limit must not be NULL"); |
1374 | 78 |
size_t limitOffset = heapWordToOffset(limit); |
79 |
size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset); |
|
80 |
HeapWord* nextAddr = offsetToHeapWord(nextOffset); |
|
81 |
assert(nextAddr >= addr, "get_next_one postcondition"); |
|
82 |
assert(nextAddr == limit || isMarked(nextAddr), |
|
83 |
"get_next_one postcondition"); |
|
84 |
return nextAddr; |
|
85 |
} |
|
86 |
||
87 |
#ifndef PRODUCT |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
88 |
bool G1CMBitMapRO::covers(MemRegion heap_rs) const { |
1374 | 89 |
// assert(_bm.map() == _virtual_space.low(), "map inconsistency"); |
13752
92f03fcf979a
7197906: BlockOffsetArray::power_to_cards_back() needs to handle > 32 bit shifts
brutisso
parents:
13728
diff
changeset
|
90 |
assert(((size_t)_bm.size() * ((size_t)1 << _shifter)) == _bmWordSize, |
1374 | 91 |
"size inconsistency"); |
26160 | 92 |
return _bmStartWord == (HeapWord*)(heap_rs.start()) && |
93 |
_bmWordSize == heap_rs.word_size(); |
|
1374 | 94 |
} |
95 |
#endif |
|
96 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
97 |
void G1CMBitMapRO::print_on_error(outputStream* st, const char* prefix) const { |
16685
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
98 |
_bm.print_on_error(st, prefix); |
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
99 |
} |
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
100 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
101 |
size_t G1CMBitMap::compute_size(size_t heap_size) { |
30158
bd6094906ef8
8058354: SPECjvm2008-Derby -2.7% performance regression on Solaris-X64 starting with 9-b29
tschatzl
parents:
30153
diff
changeset
|
102 |
return ReservedSpace::allocation_align_size_up(heap_size / mark_distance()); |
26160 | 103 |
} |
104 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
105 |
size_t G1CMBitMap::mark_distance() { |
26160 | 106 |
return MinObjAlignmentInBytes * BitsPerByte; |
107 |
} |
|
108 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
109 |
void G1CMBitMap::initialize(MemRegion heap, G1RegionToSpaceMapper* storage) { |
26160 | 110 |
_bmStartWord = heap.start(); |
111 |
_bmWordSize = heap.word_size(); |
|
112 |
||
38177 | 113 |
_bm = BitMapView((BitMap::bm_word_t*) storage->reserved().start(), _bmWordSize >> _shifter); |
26160 | 114 |
|
115 |
storage->set_mapping_changed_listener(&_listener); |
|
116 |
} |
|
117 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
118 |
void G1CMBitMapMappingChangedListener::on_commit(uint start_region, size_t num_regions, bool zero_filled) { |
27149 | 119 |
if (zero_filled) { |
120 |
return; |
|
121 |
} |
|
26160 | 122 |
// We need to clear the bitmap on commit, removing any existing information. |
123 |
MemRegion mr(G1CollectedHeap::heap()->bottom_addr_for_region(start_region), num_regions * HeapRegion::GrainWords); |
|
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
124 |
_bm->clear_range(mr); |
26160 | 125 |
} |
126 |
||
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
127 |
void G1CMBitMap::clear_range(MemRegion mr) { |
1374 | 128 |
mr.intersection(MemRegion(_bmStartWord, _bmWordSize)); |
129 |
assert(!mr.is_empty(), "unexpected empty region"); |
|
130 |
// convert address range into offset range |
|
131 |
_bm.at_put_range(heapWordToOffset(mr.start()), |
|
132 |
heapWordToOffset(mr.end()), false); |
|
133 |
} |
|
134 |
||
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
135 |
G1CMMarkStack::G1CMMarkStack() : |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
136 |
_reserved_space(), |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
137 |
_base(NULL), |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
138 |
_capacity(0), |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
139 |
_saved_index((size_t)AllBits), |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
140 |
_should_expand(false) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
141 |
set_empty(); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
142 |
} |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
143 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
144 |
bool G1CMMarkStack::resize(size_t new_capacity) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
145 |
assert(is_empty(), "Only resize when stack is empty."); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
146 |
assert(new_capacity <= MarkStackSizeMax, |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
147 |
"Trying to resize stack to " SIZE_FORMAT " elements when the maximum is " SIZE_FORMAT, new_capacity, MarkStackSizeMax); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
148 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
149 |
size_t reservation_size = ReservedSpace::allocation_align_size_up(new_capacity * sizeof(oop)); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
150 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
151 |
ReservedSpace rs(reservation_size); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
152 |
if (!rs.is_reserved()) { |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
153 |
log_warning(gc)("Failed to reserve memory for new overflow mark stack with " SIZE_FORMAT " elements and size " SIZE_FORMAT "B.", new_capacity, reservation_size); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
154 |
return false; |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
155 |
} |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
156 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
157 |
VirtualSpace vs; |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
158 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
159 |
if (!vs.initialize(rs, rs.size())) { |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
160 |
rs.release(); |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
161 |
log_warning(gc)("Failed to commit memory for new overflow mark stack of size " SIZE_FORMAT "B.", rs.size()); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
162 |
return false; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
163 |
} |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
164 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
165 |
assert(vs.committed_size() == rs.size(), "Failed to commit all of the mark stack."); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
166 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
167 |
// Release old mapping. |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
168 |
_reserved_space.release(); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
169 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
170 |
// Save new mapping for future unmapping. |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
171 |
_reserved_space = rs; |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
172 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
173 |
MemTracker::record_virtual_memory_type((address)_reserved_space.base(), mtGC); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
174 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
175 |
_base = (oop*) vs.low(); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
176 |
_capacity = new_capacity; |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
177 |
set_empty(); |
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
178 |
_should_expand = false; |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
179 |
|
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
180 |
return true; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
181 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
182 |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
183 |
bool G1CMMarkStack::allocate(size_t capacity) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
184 |
return resize(capacity); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
185 |
} |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
186 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
187 |
void G1CMMarkStack::expand() { |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
188 |
// Clear expansion flag |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
189 |
_should_expand = false; |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
190 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
191 |
if (_capacity == MarkStackSizeMax) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
192 |
log_debug(gc)("Can not expand overflow mark stack further, already at maximum capacity of " SIZE_FORMAT " elements.", _capacity); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
193 |
return; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
194 |
} |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
195 |
size_t old_capacity = _capacity; |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
196 |
// Double capacity if possible |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
197 |
size_t new_capacity = MIN2(old_capacity * 2, MarkStackSizeMax); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
198 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
199 |
if (resize(new_capacity)) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
200 |
log_debug(gc)("Expanded marking stack capacity from " SIZE_FORMAT " to " SIZE_FORMAT " elements", |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
201 |
old_capacity, new_capacity); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
202 |
} else { |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
203 |
log_warning(gc)("Failed to expand marking stack capacity from " SIZE_FORMAT " to " SIZE_FORMAT " elements", |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
204 |
old_capacity, new_capacity); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
205 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
206 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
207 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
208 |
G1CMMarkStack::~G1CMMarkStack() { |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
209 |
if (_base != NULL) { |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
210 |
_base = NULL; |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
211 |
_reserved_space.release(); |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
212 |
} |
1374 | 213 |
} |
214 |
||
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
215 |
void G1CMMarkStack::par_push_arr(oop* buffer, size_t n) { |
1374 | 216 |
MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
217 |
size_t start = _index; |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
218 |
size_t next_index = start + n; |
1374 | 219 |
if (next_index > _capacity) { |
220 |
_overflow = true; |
|
221 |
return; |
|
222 |
} |
|
223 |
// Otherwise. |
|
224 |
_index = next_index; |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
225 |
for (size_t i = 0; i < n; i++) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
226 |
size_t ind = start + i; |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
227 |
assert(ind < _capacity, "By overflow test above."); |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
228 |
_base[ind] = buffer[i]; |
1374 | 229 |
} |
230 |
} |
|
231 |
||
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
232 |
bool G1CMMarkStack::par_pop_arr(oop* buffer, size_t max, size_t* n) { |
1374 | 233 |
MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
234 |
size_t index = _index; |
1374 | 235 |
if (index == 0) { |
236 |
*n = 0; |
|
237 |
return false; |
|
238 |
} else { |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
239 |
size_t k = MIN2(max, index); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
240 |
size_t new_ind = index - k; |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
241 |
for (size_t j = 0; j < k; j++) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
242 |
buffer[j] = _base[new_ind + j]; |
1374 | 243 |
} |
244 |
_index = new_ind; |
|
245 |
*n = k; |
|
246 |
return true; |
|
247 |
} |
|
248 |
} |
|
249 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
250 |
void G1CMMarkStack::note_start_of_gc() { |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
251 |
assert(_saved_index == (size_t)AllBits, "note_start_of_gc()/end_of_gc() calls bracketed incorrectly"); |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
252 |
_saved_index = _index; |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
253 |
} |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
254 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
255 |
void G1CMMarkStack::note_end_of_gc() { |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
256 |
guarantee(!stack_modified(), "Saved index " SIZE_FORMAT " must be the same as " SIZE_FORMAT, _saved_index, _index); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
257 |
|
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
258 |
_saved_index = (size_t)AllBits; |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
259 |
} |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
260 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
261 |
G1CMRootRegions::G1CMRootRegions() : |
38183
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
262 |
_cm(NULL), _scan_in_progress(false), |
38162
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
263 |
_should_abort(false), _claimed_survivor_index(0) { } |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
264 |
|
38183
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
265 |
void G1CMRootRegions::init(const G1SurvivorRegions* survivors, G1ConcurrentMark* cm) { |
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
266 |
_survivors = survivors; |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
267 |
_cm = cm; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
268 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
269 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
270 |
void G1CMRootRegions::prepare_for_scan() { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
271 |
assert(!scan_in_progress(), "pre-condition"); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
272 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
273 |
// Currently, only survivors can be root regions. |
38162
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
274 |
_claimed_survivor_index = 0; |
38268
222eea004d99
8156660: JDK-8150393 does not set _scan_in_progress properly
tschatzl
parents:
38184
diff
changeset
|
275 |
_scan_in_progress = _survivors->regions()->is_nonempty(); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
276 |
_should_abort = false; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
277 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
278 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
279 |
HeapRegion* G1CMRootRegions::claim_next() { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
280 |
if (_should_abort) { |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
281 |
// If someone has set the should_abort flag, we return NULL to |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
282 |
// force the caller to bail out of their loop. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
283 |
return NULL; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
284 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
285 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
286 |
// Currently, only survivors can be root regions. |
38183
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
287 |
const GrowableArray<HeapRegion*>* survivor_regions = _survivors->regions(); |
38162
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
288 |
|
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
289 |
int claimed_index = Atomic::add(1, &_claimed_survivor_index) - 1; |
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
290 |
if (claimed_index < survivor_regions->length()) { |
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
291 |
return survivor_regions->at(claimed_index); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
292 |
} |
38162
4e2c3433a3ae
8150393: Maintain the set of survivor regions in an array between GCs
mgerdin
parents:
38155
diff
changeset
|
293 |
return NULL; |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
294 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
295 |
|
38270
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
296 |
uint G1CMRootRegions::num_root_regions() const { |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
297 |
return (uint)_survivors->regions()->length(); |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
298 |
} |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
299 |
|
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
300 |
void G1CMRootRegions::notify_scan_done() { |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
301 |
MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag); |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
302 |
_scan_in_progress = false; |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
303 |
RootRegionScan_lock->notify_all(); |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
304 |
} |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
305 |
|
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
306 |
void G1CMRootRegions::cancel_scan() { |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
307 |
notify_scan_done(); |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
308 |
} |
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
309 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
310 |
void G1CMRootRegions::scan_finished() { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
311 |
assert(scan_in_progress(), "pre-condition"); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
312 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
313 |
// Currently, only survivors can be root regions. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
314 |
if (!_should_abort) { |
38183
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
315 |
assert(_claimed_survivor_index >= 0, "otherwise comparison is invalid: %d", _claimed_survivor_index); |
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
316 |
assert((uint)_claimed_survivor_index >= _survivors->length(), |
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
317 |
"we should have claimed all survivors, claimed index = %u, length = %u", |
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
318 |
(uint)_claimed_survivor_index, _survivors->length()); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
319 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
320 |
|
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
321 |
notify_scan_done(); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
322 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
323 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
324 |
bool G1CMRootRegions::wait_until_scan_finished() { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
325 |
if (!scan_in_progress()) return false; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
326 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
327 |
{ |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
328 |
MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
329 |
while (scan_in_progress()) { |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
330 |
RootRegionScan_lock->wait(Mutex::_no_safepoint_check_flag); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
331 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
332 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
333 |
return true; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
334 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
335 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
336 |
uint G1ConcurrentMark::scale_parallel_threads(uint n_par_threads) { |
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
337 |
return MAX2((n_par_threads + 2) / 4, 1U); |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
338 |
} |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
339 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
340 |
G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h, G1RegionToSpaceMapper* prev_bitmap_storage, G1RegionToSpaceMapper* next_bitmap_storage) : |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
341 |
_g1h(g1h), |
26160 | 342 |
_markBitMap1(), |
343 |
_markBitMap2(), |
|
1374 | 344 |
_parallel_marking_threads(0), |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
345 |
_max_parallel_marking_threads(0), |
1374 | 346 |
_sleep_factor(0.0), |
347 |
_marking_task_overhead(1.0), |
|
7923 | 348 |
_cleanup_list("Cleanup List"), |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
349 |
|
1374 | 350 |
_prevMarkBitMap(&_markBitMap1), |
351 |
_nextMarkBitMap(&_markBitMap2), |
|
352 |
||
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
353 |
_global_mark_stack(), |
1374 | 354 |
// _finger set in set_non_marking_state |
355 |
||
31330
77061bb01b18
8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents:
30884
diff
changeset
|
356 |
_max_worker_id(ParallelGCThreads), |
1374 | 357 |
// _active_tasks set in set_non_marking_state |
358 |
// _tasks set inside the constructor |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
359 |
_task_queues(new G1CMTaskQueueSet((int) _max_worker_id)), |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
360 |
_terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)), |
1374 | 361 |
|
362 |
_has_overflown(false), |
|
363 |
_concurrent(false), |
|
2145
da1dfec15623
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
1623
diff
changeset
|
364 |
_has_aborted(false), |
da1dfec15623
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
1623
diff
changeset
|
365 |
_restart_for_overflow(false), |
da1dfec15623
6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents:
1623
diff
changeset
|
366 |
_concurrent_marking_in_progress(false), |
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
367 |
_gc_timer_cm(new (ResourceObj::C_HEAP, mtGC) ConcurrentGCTimer()), |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
368 |
_gc_tracer_cm(new (ResourceObj::C_HEAP, mtGC) G1OldTracer()), |
1374 | 369 |
|
370 |
// _verbose_level set below |
|
371 |
||
372 |
_init_times(), |
|
373 |
_remark_times(), _remark_mark_times(), _remark_weak_ref_times(), |
|
374 |
_cleanup_times(), |
|
375 |
_total_counting_time(0.0), |
|
376 |
_total_rs_scrub_time(0.0), |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
377 |
|
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
378 |
_parallel_workers(NULL), |
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
379 |
|
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
380 |
_completed_initialization(false) { |
1374 | 381 |
|
26160 | 382 |
_markBitMap1.initialize(g1h->reserved_region(), prev_bitmap_storage); |
383 |
_markBitMap2.initialize(g1h->reserved_region(), next_bitmap_storage); |
|
1374 | 384 |
|
385 |
// Create & start a ConcurrentMark thread. |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
386 |
_cmThread = new ConcurrentMarkThread(this); |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
387 |
assert(cmThread() != NULL, "CM Thread should have been created"); |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
388 |
assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm"); |
22220
eb467dfb9585
8029326: G1 does not check if threads gets created
ehelin
parents:
20282
diff
changeset
|
389 |
if (_cmThread->osthread() == NULL) { |
eb467dfb9585
8029326: G1 does not check if threads gets created
ehelin
parents:
20282
diff
changeset
|
390 |
vm_shutdown_during_initialization("Could not create ConcurrentMarkThread"); |
eb467dfb9585
8029326: G1 does not check if threads gets created
ehelin
parents:
20282
diff
changeset
|
391 |
} |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
392 |
|
1374 | 393 |
assert(CGC_lock != NULL, "Where's the CGC_lock?"); |
26160 | 394 |
assert(_markBitMap1.covers(g1h->reserved_region()), "_markBitMap1 inconsistency"); |
395 |
assert(_markBitMap2.covers(g1h->reserved_region()), "_markBitMap2 inconsistency"); |
|
1374 | 396 |
|
397 |
SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set(); |
|
5033 | 398 |
satb_qs.set_buffer_size(G1SATBBufferSize); |
1374 | 399 |
|
38183
cb68e4923223
8150721: Don't explicitly manage G1 young regions in YoungList
mgerdin
parents:
38162
diff
changeset
|
400 |
_root_regions.init(_g1h->survivor(), this); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
401 |
|
5035 | 402 |
if (ConcGCThreads > ParallelGCThreads) { |
37073
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
403 |
log_warning(gc)("Can't have more ConcGCThreads (%u) than ParallelGCThreads (%u).", |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
404 |
ConcGCThreads, ParallelGCThreads); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
405 |
return; |
1374 | 406 |
} |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
407 |
if (!FLAG_IS_DEFAULT(ConcGCThreads) && ConcGCThreads > 0) { |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
408 |
// Note: ConcGCThreads has precedence over G1MarkingOverheadPercent |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
409 |
// if both are set |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
410 |
_sleep_factor = 0.0; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
411 |
_marking_task_overhead = 1.0; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
412 |
} else if (G1MarkingOverheadPercent > 0) { |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
413 |
// We will calculate the number of parallel marking threads based |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
414 |
// on a target overhead with respect to the soft real-time goal |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
415 |
double marking_overhead = (double) G1MarkingOverheadPercent / 100.0; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
416 |
double overall_cm_overhead = |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
417 |
(double) MaxGCPauseMillis * marking_overhead / |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
418 |
(double) GCPauseIntervalMillis; |
35902
c194dfa0a187
8148771: os::active_processor_count() returns garbage which causes VM to crash
dholmes
parents:
35882
diff
changeset
|
419 |
double cpu_ratio = 1.0 / (double) os::processor_count(); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
420 |
double marking_thread_num = ceil(overall_cm_overhead / cpu_ratio); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
421 |
double marking_task_overhead = |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
422 |
overall_cm_overhead / marking_thread_num * |
35902
c194dfa0a187
8148771: os::active_processor_count() returns garbage which causes VM to crash
dholmes
parents:
35882
diff
changeset
|
423 |
(double) os::processor_count(); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
424 |
double sleep_factor = |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
425 |
(1.0 - marking_task_overhead) / marking_task_overhead; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
426 |
|
31330
77061bb01b18
8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents:
30884
diff
changeset
|
427 |
FLAG_SET_ERGO(uint, ConcGCThreads, (uint) marking_thread_num); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
428 |
_sleep_factor = sleep_factor; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
429 |
_marking_task_overhead = marking_task_overhead; |
1374 | 430 |
} else { |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
431 |
// Calculate the number of parallel marking threads by scaling |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
432 |
// the number of parallel GC threads. |
31330
77061bb01b18
8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents:
30884
diff
changeset
|
433 |
uint marking_thread_num = scale_parallel_threads(ParallelGCThreads); |
77061bb01b18
8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents:
30884
diff
changeset
|
434 |
FLAG_SET_ERGO(uint, ConcGCThreads, marking_thread_num); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
435 |
_sleep_factor = 0.0; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
436 |
_marking_task_overhead = 1.0; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
437 |
} |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
438 |
|
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
439 |
assert(ConcGCThreads > 0, "Should have been set"); |
38637
dba1e7561542
8153582: Logging of ConcGCThreads is done too early
jprovino
parents:
38270
diff
changeset
|
440 |
log_debug(gc)("ConcGCThreads: %u", ConcGCThreads); |
dba1e7561542
8153582: Logging of ConcGCThreads is done too early
jprovino
parents:
38270
diff
changeset
|
441 |
log_debug(gc)("ParallelGCThreads: %u", ParallelGCThreads); |
31330
77061bb01b18
8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents:
30884
diff
changeset
|
442 |
_parallel_marking_threads = ConcGCThreads; |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
443 |
_max_parallel_marking_threads = _parallel_marking_threads; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
444 |
|
32360 | 445 |
_parallel_workers = new WorkGang("G1 Marker", |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
446 |
_max_parallel_marking_threads, false, true); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
447 |
if (_parallel_workers == NULL) { |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
448 |
vm_exit_during_initialization("Failed necessary allocation."); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
449 |
} else { |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
450 |
_parallel_workers->initialize_workers(); |
1374 | 451 |
} |
452 |
||
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
453 |
if (FLAG_IS_DEFAULT(MarkStackSize)) { |
29697
92501504191b
8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents:
29472
diff
changeset
|
454 |
size_t mark_stack_size = |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
455 |
MIN2(MarkStackSizeMax, |
29697
92501504191b
8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents:
29472
diff
changeset
|
456 |
MAX2(MarkStackSize, (size_t) (parallel_marking_threads() * TASKQUEUE_SIZE))); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
457 |
// Verify that the calculated value for MarkStackSize is in range. |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
458 |
// It would be nice to use the private utility routine from Arguments. |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
459 |
if (!(mark_stack_size >= 1 && mark_stack_size <= MarkStackSizeMax)) { |
37073
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
460 |
log_warning(gc)("Invalid value calculated for MarkStackSize (" SIZE_FORMAT "): " |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
461 |
"must be between 1 and " SIZE_FORMAT, |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
462 |
mark_stack_size, MarkStackSizeMax); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
463 |
return; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
464 |
} |
29697
92501504191b
8074459: Flags handling memory sizes should be of type size_t
jwilhelm
parents:
29472
diff
changeset
|
465 |
FLAG_SET_ERGO(size_t, MarkStackSize, mark_stack_size); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
466 |
} else { |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
467 |
// Verify MarkStackSize is in range. |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
468 |
if (FLAG_IS_CMDLINE(MarkStackSize)) { |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
469 |
if (FLAG_IS_DEFAULT(MarkStackSizeMax)) { |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
470 |
if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) { |
37073
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
471 |
log_warning(gc)("Invalid value specified for MarkStackSize (" SIZE_FORMAT "): " |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
472 |
"must be between 1 and " SIZE_FORMAT, |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
473 |
MarkStackSize, MarkStackSizeMax); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
474 |
return; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
475 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
476 |
} else if (FLAG_IS_CMDLINE(MarkStackSizeMax)) { |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
477 |
if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) { |
37073
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
478 |
log_warning(gc)("Invalid value specified for MarkStackSize (" SIZE_FORMAT ")" |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
479 |
" or for MarkStackSizeMax (" SIZE_FORMAT ")", |
c39d0903390b
8151605: Change warning() to log_warning(gc) in the GC code
brutisso
parents:
36588
diff
changeset
|
480 |
MarkStackSize, MarkStackSizeMax); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
481 |
return; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
482 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
483 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
484 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
485 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
486 |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
487 |
if (!_global_mark_stack.allocate(MarkStackSize)) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
488 |
vm_exit_during_initialization("Failed to allocate initial concurrent mark overflow mark stack."); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
489 |
return; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
490 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
491 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
492 |
_tasks = NEW_C_HEAP_ARRAY(G1CMTask*, _max_worker_id, mtGC); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
493 |
_accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC); |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
494 |
|
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
495 |
// so that the assertion in MarkingTaskQueue::task_queue doesn't fail |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
496 |
_active_tasks = _max_worker_id; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
497 |
|
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
498 |
for (uint i = 0; i < _max_worker_id; ++i) { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
499 |
G1CMTaskQueue* task_queue = new G1CMTaskQueue(); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
500 |
task_queue->initialize(); |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
501 |
_task_queues->register_queue(i, task_queue); |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
502 |
|
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
503 |
_tasks[i] = new G1CMTask(i, this, task_queue, _task_queues); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
504 |
|
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
505 |
_accum_task_vtime[i] = 0.0; |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
506 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
507 |
|
1374 | 508 |
// so that the call below can read a sensible value |
26160 | 509 |
_heap_start = g1h->reserved_region().start(); |
1374 | 510 |
set_non_marking_state(); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
511 |
_completed_initialization = true; |
1374 | 512 |
} |
513 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
514 |
void G1ConcurrentMark::reset() { |
1374 | 515 |
// Starting values for these two. This should be called in a STW |
26160 | 516 |
// phase. |
517 |
MemRegion reserved = _g1h->g1_reserved(); |
|
518 |
_heap_start = reserved.start(); |
|
519 |
_heap_end = reserved.end(); |
|
1374 | 520 |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
521 |
// Separated the asserts so that we know which one fires. |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
522 |
assert(_heap_start != NULL, "heap bounds should look ok"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
523 |
assert(_heap_end != NULL, "heap bounds should look ok"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
524 |
assert(_heap_start < _heap_end, "heap bounds should look ok"); |
1374 | 525 |
|
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
526 |
// Reset all the marking data structures and any necessary flags |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
527 |
reset_marking_state(); |
1374 | 528 |
|
529 |
// We do reset all of them, since different phases will use |
|
530 |
// different number of active threads. So, it's easiest to have all |
|
531 |
// of them ready. |
|
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
532 |
for (uint i = 0; i < _max_worker_id; ++i) { |
1374 | 533 |
_tasks[i]->reset(_nextMarkBitMap); |
6761
f9191297ce83
6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents:
6759
diff
changeset
|
534 |
} |
1374 | 535 |
|
536 |
// we need this to make sure that the flag is on during the evac |
|
537 |
// pause with initial mark piggy-backed |
|
538 |
set_concurrent_marking_in_progress(); |
|
539 |
} |
|
540 |
||
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
541 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
542 |
void G1ConcurrentMark::reset_marking_state(bool clear_overflow) { |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
543 |
_global_mark_stack.set_should_expand(has_overflown()); |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
544 |
_global_mark_stack.set_empty(); // Also clears the overflow stack's overflow flag |
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
545 |
if (clear_overflow) { |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
546 |
clear_has_overflown(); |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
547 |
} else { |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
548 |
assert(has_overflown(), "pre-condition"); |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
549 |
} |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
550 |
_finger = _heap_start; |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
551 |
|
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
552 |
for (uint i = 0; i < _max_worker_id; ++i) { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
553 |
G1CMTaskQueue* queue = _task_queues->queue(i); |
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
554 |
queue->set_empty(); |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
555 |
} |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
556 |
} |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
557 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
558 |
void G1ConcurrentMark::set_concurrency(uint active_tasks) { |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
559 |
assert(active_tasks <= _max_worker_id, "we should not have more"); |
1374 | 560 |
|
561 |
_active_tasks = active_tasks; |
|
562 |
// Need to update the three data structures below according to the |
|
563 |
// number of active threads for this phase. |
|
564 |
_terminator = ParallelTaskTerminator((int) active_tasks, _task_queues); |
|
565 |
_first_overflow_barrier_sync.set_n_workers((int) active_tasks); |
|
566 |
_second_overflow_barrier_sync.set_n_workers((int) active_tasks); |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
567 |
} |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
568 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
569 |
void G1ConcurrentMark::set_concurrency_and_phase(uint active_tasks, bool concurrent) { |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
570 |
set_concurrency(active_tasks); |
1374 | 571 |
|
572 |
_concurrent = concurrent; |
|
573 |
// We propagate this to all tasks, not just the active ones. |
|
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
574 |
for (uint i = 0; i < _max_worker_id; ++i) |
1374 | 575 |
_tasks[i]->set_concurrent(concurrent); |
576 |
||
577 |
if (concurrent) { |
|
578 |
set_concurrent_marking_in_progress(); |
|
579 |
} else { |
|
580 |
// We currently assume that the concurrent flag has been set to |
|
581 |
// false before we start remark. At this point we should also be |
|
582 |
// in a STW phase. |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
583 |
assert(!concurrent_marking_in_progress(), "invariant"); |
24469
33e039f8ee55
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
24468
diff
changeset
|
584 |
assert(out_of_regions(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
585 |
"only way to get here: _finger: " PTR_FORMAT ", _heap_end: " PTR_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
586 |
p2i(_finger), p2i(_heap_end)); |
1374 | 587 |
} |
588 |
} |
|
589 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
590 |
void G1ConcurrentMark::set_non_marking_state() { |
1374 | 591 |
// We set the global marking state to some default values when we're |
592 |
// not doing marking. |
|
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
593 |
reset_marking_state(); |
1374 | 594 |
_active_tasks = 0; |
595 |
clear_concurrent_marking_in_progress(); |
|
596 |
} |
|
597 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
598 |
G1ConcurrentMark::~G1ConcurrentMark() { |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
599 |
// The G1ConcurrentMark instance is never freed. |
11403 | 600 |
ShouldNotReachHere(); |
1374 | 601 |
} |
602 |
||
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
603 |
class G1ClearBitMapTask : public AbstractGangTask { |
38155
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
604 |
public: |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
605 |
static size_t chunk_size() { return M; } |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
606 |
|
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
607 |
private: |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
608 |
// Heap region closure used for clearing the given mark bitmap. |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
609 |
class G1ClearBitmapHRClosure : public HeapRegionClosure { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
610 |
private: |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
611 |
G1CMBitMap* _bitmap; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
612 |
G1ConcurrentMark* _cm; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
613 |
public: |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
614 |
G1ClearBitmapHRClosure(G1CMBitMap* bitmap, G1ConcurrentMark* cm) : HeapRegionClosure(), _cm(cm), _bitmap(bitmap) { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
615 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
616 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
617 |
virtual bool doHeapRegion(HeapRegion* r) { |
38155
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
618 |
size_t const chunk_size_in_words = G1ClearBitMapTask::chunk_size() / HeapWordSize; |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
619 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
620 |
HeapWord* cur = r->bottom(); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
621 |
HeapWord* const end = r->end(); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
622 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
623 |
while (cur < end) { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
624 |
MemRegion mr(cur, MIN2(cur + chunk_size_in_words, end)); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
625 |
_bitmap->clear_range(mr); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
626 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
627 |
cur += chunk_size_in_words; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
628 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
629 |
// Abort iteration if after yielding the marking has been aborted. |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
630 |
if (_cm != NULL && _cm->do_yield_check() && _cm->has_aborted()) { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
631 |
return true; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
632 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
633 |
// Repeat the asserts from before the start of the closure. We will do them |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
634 |
// as asserts here to minimize their overhead on the product. However, we |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
635 |
// will have them as guarantees at the beginning / end of the bitmap |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
636 |
// clearing to get some checking in the product. |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
637 |
assert(_cm == NULL || _cm->cmThread()->during_cycle(), "invariant"); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
638 |
assert(_cm == NULL || !G1CollectedHeap::heap()->collector_state()->mark_in_progress(), "invariant"); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
639 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
640 |
assert(cur == end, "Must have completed iteration over the bitmap for region %u.", r->hrm_index()); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
641 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
642 |
return false; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
643 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
644 |
}; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
645 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
646 |
G1ClearBitmapHRClosure _cl; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
647 |
HeapRegionClaimer _hr_claimer; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
648 |
bool _suspendible; // If the task is suspendible, workers must join the STS. |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
649 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
650 |
public: |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
651 |
G1ClearBitMapTask(G1CMBitMap* bitmap, G1ConcurrentMark* cm, uint n_workers, bool suspendible) : |
38155
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
652 |
AbstractGangTask("G1 Clear Bitmap"), |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
653 |
_cl(bitmap, suspendible ? cm : NULL), |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
654 |
_hr_claimer(n_workers), |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
655 |
_suspendible(suspendible) |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
656 |
{ } |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
657 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
658 |
void work(uint worker_id) { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
659 |
SuspendibleThreadSetJoiner sts_join(_suspendible); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
660 |
G1CollectedHeap::heap()->heap_region_par_iterate(&_cl, worker_id, &_hr_claimer, true); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
661 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
662 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
663 |
bool is_complete() { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
664 |
return _cl.complete(); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
665 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
666 |
}; |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
667 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
668 |
void G1ConcurrentMark::clear_bitmap(G1CMBitMap* bitmap, WorkGang* workers, bool may_yield) { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
669 |
assert(may_yield || SafepointSynchronize::is_at_safepoint(), "Non-yielding bitmap clear only allowed at safepoint."); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
670 |
|
38155
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
671 |
size_t const num_bytes_to_clear = (HeapRegion::GrainBytes * _g1h->num_regions()) / G1CMBitMap::heap_map_factor(); |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
672 |
size_t const num_chunks = align_size_up(num_bytes_to_clear, G1ClearBitMapTask::chunk_size()) / G1ClearBitMapTask::chunk_size(); |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
673 |
|
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
674 |
uint const num_workers = (uint)MIN2(num_chunks, (size_t)workers->active_workers()); |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
675 |
|
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
676 |
G1ClearBitMapTask cl(bitmap, this, num_workers, may_yield); |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
677 |
|
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
678 |
log_debug(gc, ergo)("Running %s with %u workers for " SIZE_FORMAT " work units.", cl.name(), num_workers, num_chunks); |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
679 |
workers->run_task(&cl, num_workers); |
a4501a2965dc
8155230: Tune thread usage for mark bitmap clear
tschatzl
parents:
37989
diff
changeset
|
680 |
guarantee(!may_yield || cl.is_complete(), "Must have completed iteration when not yielding."); |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
681 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
682 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
683 |
void G1ConcurrentMark::cleanup_for_next_mark() { |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
684 |
// Make sure that the concurrent mark thread looks to still be in |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
685 |
// the current cycle. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
686 |
guarantee(cmThread()->during_cycle(), "invariant"); |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
687 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
688 |
// We are finishing up the current cycle by clearing the next |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
689 |
// marking bitmap and getting it ready for the next cycle. During |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
690 |
// this time no other cycle can start. So, let's make sure that this |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
691 |
// is the case. |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
692 |
guarantee(!_g1h->collector_state()->mark_in_progress(), "invariant"); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
693 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
694 |
clear_bitmap(_nextMarkBitMap, _parallel_workers, true); |
26160 | 695 |
|
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
696 |
// Clear the live count data. If the marking has been aborted, the abort() |
26160 | 697 |
// call already did that. |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
698 |
if (!has_aborted()) { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
699 |
clear_live_data(_parallel_workers); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
700 |
DEBUG_ONLY(verify_live_data_clear()); |
5243
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
701 |
} |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
702 |
|
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
703 |
// Repeat the asserts from above. |
99e5a8f5d81f
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
5242
diff
changeset
|
704 |
guarantee(cmThread()->during_cycle(), "invariant"); |
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
705 |
guarantee(!_g1h->collector_state()->mark_in_progress(), "invariant"); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
706 |
} |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
707 |
|
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
708 |
void G1ConcurrentMark::clear_prev_bitmap(WorkGang* workers) { |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
709 |
assert(SafepointSynchronize::is_at_safepoint(), "Should only clear the entire prev bitmap at a safepoint."); |
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
710 |
clear_bitmap((G1CMBitMap*)_prevMarkBitMap, workers, false); |
1374 | 711 |
} |
712 |
||
26160 | 713 |
class CheckBitmapClearHRClosure : public HeapRegionClosure { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
714 |
G1CMBitMap* _bitmap; |
26160 | 715 |
bool _error; |
716 |
public: |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
717 |
CheckBitmapClearHRClosure(G1CMBitMap* bitmap) : _bitmap(bitmap) { |
26160 | 718 |
} |
719 |
||
720 |
virtual bool doHeapRegion(HeapRegion* r) { |
|
26326
d36e8d9dcac8
8054808: Bitmap verification sometimes fails after Full GC aborts concurrent mark.
tschatzl
parents:
26320
diff
changeset
|
721 |
// This closure can be called concurrently to the mutator, so we must make sure |
d36e8d9dcac8
8054808: Bitmap verification sometimes fails after Full GC aborts concurrent mark.
tschatzl
parents:
26320
diff
changeset
|
722 |
// that the result of the getNextMarkedWordAddress() call is compared to the |
d36e8d9dcac8
8054808: Bitmap verification sometimes fails after Full GC aborts concurrent mark.
tschatzl
parents:
26320
diff
changeset
|
723 |
// value passed to it as limit to detect any found bits. |
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
724 |
// end never changes in G1. |
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
725 |
HeapWord* end = r->end(); |
26326
d36e8d9dcac8
8054808: Bitmap verification sometimes fails after Full GC aborts concurrent mark.
tschatzl
parents:
26320
diff
changeset
|
726 |
return _bitmap->getNextMarkedWordAddress(r->bottom(), end) != end; |
26160 | 727 |
} |
728 |
}; |
|
729 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
730 |
bool G1ConcurrentMark::nextMarkBitmapIsClear() { |
26160 | 731 |
CheckBitmapClearHRClosure cl(_nextMarkBitMap); |
732 |
_g1h->heap_region_iterate(&cl); |
|
733 |
return cl.complete(); |
|
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25492
diff
changeset
|
734 |
} |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25492
diff
changeset
|
735 |
|
1374 | 736 |
class NoteStartOfMarkHRClosure: public HeapRegionClosure { |
737 |
public: |
|
738 |
bool doHeapRegion(HeapRegion* r) { |
|
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
739 |
r->note_start_of_marking(); |
1374 | 740 |
return false; |
741 |
} |
|
742 |
}; |
|
743 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
744 |
void G1ConcurrentMark::checkpointRootsInitialPre() { |
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37474
diff
changeset
|
745 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37474
diff
changeset
|
746 |
G1Policy* g1p = g1h->g1_policy(); |
1374 | 747 |
|
24848 | 748 |
_has_aborted = false; |
1374 | 749 |
|
22551 | 750 |
// Initialize marking structures. This has to be done in a STW phase. |
1374 | 751 |
reset(); |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
752 |
|
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
753 |
// For each region note start of marking. |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
754 |
NoteStartOfMarkHRClosure startcl; |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
755 |
g1h->heap_region_iterate(&startcl); |
1374 | 756 |
} |
757 |
||
758 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
759 |
void G1ConcurrentMark::checkpointRootsInitialPost() { |
1374 | 760 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
761 |
||
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
762 |
// Start Concurrent Marking weak-reference discovery. |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
763 |
ReferenceProcessor* rp = g1h->ref_processor_cm(); |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
764 |
// enable ("weak") refs discovery |
28212
647b7d0efb88
8066827: Remove ReferenceProcessor::clean_up_discovered_references()
kbarrett
parents:
27897
diff
changeset
|
765 |
rp->enable_discovery(); |
1610
5dddd195cc86
6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents:
1606
diff
changeset
|
766 |
rp->setup_policy(false); // snapshot the soft ref policy to be used in this cycle |
1374 | 767 |
|
768 |
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); |
|
5082
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
769 |
// This is the start of the marking cycle, we're expected all |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
770 |
// threads to have SATB queues with active set to false. |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
771 |
satb_mq_set.set_active_all_threads(true, /* new active value */ |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
772 |
false /* expected_active */); |
1374 | 773 |
|
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
774 |
_root_regions.prepare_for_scan(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
775 |
|
1374 | 776 |
// update_g1_committed() will be called at the end of an evac pause |
777 |
// when marking is on. So, it's also called at the end of the |
|
778 |
// initial-mark pause to update the heap end, if the heap expands |
|
779 |
// during it. No need to call it here. |
|
780 |
} |
|
781 |
||
782 |
/* |
|
9417
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
783 |
* Notice that in the next two methods, we actually leave the STS |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
784 |
* during the barrier sync and join it immediately afterwards. If we |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
785 |
* do not do this, the following deadlock can occur: one thread could |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
786 |
* be in the barrier sync code, waiting for the other thread to also |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
787 |
* sync up, whereas another one could be trying to yield, while also |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
788 |
* waiting for the other threads to sync up too. |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
789 |
* |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
790 |
* Note, however, that this code is also used during remark and in |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
791 |
* this case we should not attempt to leave / enter the STS, otherwise |
22551 | 792 |
* we'll either hit an assert (debug / fastdebug) or deadlock |
9417
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
793 |
* (product). So we should only leave / enter the STS if we are |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
794 |
* operating concurrently. |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
795 |
* |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
796 |
* Because the thread that does the sync barrier has left the STS, it |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
797 |
* is possible to be suspended for a Full GC or an evacuation pause |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
798 |
* could occur. This is actually safe, since the entering the sync |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
799 |
* barrier is one of the last things do_marking_step() does, and it |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
800 |
* doesn't manipulate any data structures afterwards. |
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
801 |
*/ |
1374 | 802 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
803 |
void G1ConcurrentMark::enter_first_sync_barrier(uint worker_id) { |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
804 |
bool barrier_aborted; |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
805 |
{ |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
806 |
SuspendibleThreadSetLeaver sts_leave(concurrent()); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
807 |
barrier_aborted = !_first_overflow_barrier_sync.enter(); |
9417
6719a2e727c0
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
8931
diff
changeset
|
808 |
} |
24468
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
809 |
|
1374 | 810 |
// at this point everyone should have synced up and not be doing any |
811 |
// more work |
|
812 |
||
24468
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
813 |
if (barrier_aborted) { |
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
814 |
// If the barrier aborted we ignore the overflow condition and |
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
815 |
// just abort the whole marking phase as quickly as possible. |
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
816 |
return; |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
817 |
} |
1374 | 818 |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
819 |
// If we're executing the concurrent phase of marking, reset the marking |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
820 |
// state; otherwise the marking state is reset after reference processing, |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
821 |
// during the remark pause. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
822 |
// If we reset here as a result of an overflow during the remark we will |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
823 |
// see assertion failures from any subsequent set_concurrency_and_phase() |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
824 |
// calls. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
825 |
if (concurrent()) { |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
826 |
// let the task associated with with worker 0 do this |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
827 |
if (worker_id == 0) { |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
828 |
// task 0 is responsible for clearing the global data structures |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
829 |
// We should be here because of an overflow. During STW we should |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
830 |
// not clear the overflow flag since we rely on it being true when |
22551 | 831 |
// we exit this method to abort the pause and restart concurrent |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
832 |
// marking. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
833 |
reset_marking_state(true /* clear_overflow */); |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
834 |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
835 |
log_info(gc, marking)("Concurrent Mark reset for overflow"); |
1374 | 836 |
} |
837 |
} |
|
838 |
||
839 |
// after this, each task should reset its own data structures then |
|
840 |
// then go into the second barrier |
|
841 |
} |
|
842 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
843 |
void G1ConcurrentMark::enter_second_sync_barrier(uint worker_id) { |
33740
bede37d20aaf
8141037: Remove _MARKING_VERBOSE_ from the G1 code
brutisso
parents:
33733
diff
changeset
|
844 |
SuspendibleThreadSetLeaver sts_leave(concurrent()); |
bede37d20aaf
8141037: Remove _MARKING_VERBOSE_ from the G1 code
brutisso
parents:
33733
diff
changeset
|
845 |
_second_overflow_barrier_sync.enter(); |
24468
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
846 |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
847 |
// at this point everything should be re-initialized and ready to go |
1374 | 848 |
} |
849 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
850 |
class G1CMConcurrentMarkingTask: public AbstractGangTask { |
1374 | 851 |
private: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
852 |
G1ConcurrentMark* _cm; |
1374 | 853 |
ConcurrentMarkThread* _cmt; |
854 |
||
855 |
public: |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
856 |
void work(uint worker_id) { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
857 |
assert(Thread::current()->is_ConcurrentGC_thread(), |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
858 |
"this should only be done by a conc GC thread"); |
7399
4ecd771fa2d1
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
7397
diff
changeset
|
859 |
ResourceMark rm; |
1374 | 860 |
|
861 |
double start_vtime = os::elapsedVTime(); |
|
862 |
||
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
863 |
{ |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
864 |
SuspendibleThreadSetJoiner sts_join; |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
865 |
|
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
866 |
assert(worker_id < _cm->active_tasks(), "invariant"); |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
867 |
G1CMTask* the_task = _cm->task(worker_id); |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
868 |
the_task->record_start_time(); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
869 |
if (!_cm->has_aborted()) { |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
870 |
do { |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
871 |
double start_vtime_sec = os::elapsedVTime(); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
872 |
double mark_step_duration_ms = G1ConcMarkStepDurationMillis; |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
873 |
|
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
874 |
the_task->do_marking_step(mark_step_duration_ms, |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
875 |
true /* do_termination */, |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
876 |
false /* is_serial*/); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
877 |
|
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
878 |
double end_vtime_sec = os::elapsedVTime(); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
879 |
double elapsed_vtime_sec = end_vtime_sec - start_vtime_sec; |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
880 |
_cm->clear_has_overflown(); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
881 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
882 |
_cm->do_yield_check(); |
30613
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
883 |
|
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
884 |
jlong sleep_time_ms; |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
885 |
if (!_cm->has_aborted() && the_task->has_aborted()) { |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
886 |
sleep_time_ms = |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
887 |
(jlong) (elapsed_vtime_sec * _cm->sleep_factor() * 1000.0); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
888 |
{ |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
889 |
SuspendibleThreadSetLeaver sts_leave; |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
890 |
os::sleep(Thread::current(), sleep_time_ms, false); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
891 |
} |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
892 |
} |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
893 |
} while (!_cm->has_aborted() && the_task->has_aborted()); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
894 |
} |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
895 |
the_task->record_end_time(); |
a7815bb05ae2
8079579: Add SuspendibleThreadSetLeaver and make SuspendibleThreadSet::joint()/leave() private
pliden
parents:
30611
diff
changeset
|
896 |
guarantee(!the_task->has_aborted() || _cm->has_aborted(), "invariant"); |
1374 | 897 |
} |
898 |
||
899 |
double end_vtime = os::elapsedVTime(); |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
900 |
_cm->update_accum_task_vtime(worker_id, end_vtime - start_vtime); |
1374 | 901 |
} |
902 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
903 |
G1CMConcurrentMarkingTask(G1ConcurrentMark* cm, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
904 |
ConcurrentMarkThread* cmt) : |
1374 | 905 |
AbstractGangTask("Concurrent Mark"), _cm(cm), _cmt(cmt) { } |
906 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
907 |
~G1CMConcurrentMarkingTask() { } |
1374 | 908 |
}; |
909 |
||
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
910 |
// Calculates the number of active workers for a concurrent |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
911 |
// phase. |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
912 |
uint G1ConcurrentMark::calc_parallel_marking_threads() { |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
913 |
uint n_conc_workers = 0; |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
914 |
if (!UseDynamicNumberOfGCThreads || |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
915 |
(!FLAG_IS_DEFAULT(ConcGCThreads) && |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
916 |
!ForceDynamicNumberOfGCThreads)) { |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
917 |
n_conc_workers = max_parallel_marking_threads(); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
918 |
} else { |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
919 |
n_conc_workers = |
38270
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
920 |
AdaptiveSizePolicy::calc_default_active_workers(max_parallel_marking_threads(), |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
921 |
1, /* Minimum workers */ |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
922 |
parallel_marking_threads(), |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
923 |
Threads::number_of_non_daemon_threads()); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
924 |
// Don't scale down "n_conc_workers" by scale_parallel_threads() because |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
925 |
// that scaling has already gone into "_max_parallel_marking_threads". |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
926 |
} |
38270
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
927 |
assert(n_conc_workers > 0 && n_conc_workers <= max_parallel_marking_threads(), |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
928 |
"Calculated number of workers must be larger than zero and at most the maximum %u, but is %u", |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
929 |
max_parallel_marking_threads(), n_conc_workers); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
930 |
return n_conc_workers; |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
931 |
} |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
932 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
933 |
void G1ConcurrentMark::scanRootRegion(HeapRegion* hr) { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
934 |
// Currently, only survivors can be root regions. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
935 |
assert(hr->next_top_at_mark_start() == hr->bottom(), "invariant"); |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
936 |
G1RootRegionScanClosure cl(_g1h, this); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
937 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
938 |
const uintx interval = PrefetchScanIntervalInBytes; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
939 |
HeapWord* curr = hr->bottom(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
940 |
const HeapWord* end = hr->top(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
941 |
while (curr < end) { |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
942 |
Prefetch::read(curr, interval); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
943 |
oop obj = oop(curr); |
32606
fdaa30d06ada
8129417: Oop iteration clean-up to remove oop_ms_follow_contents
sjohanss
parents:
32360
diff
changeset
|
944 |
int size = obj->oop_iterate_size(&cl); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
945 |
assert(size == obj->size(), "sanity"); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
946 |
curr += size; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
947 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
948 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
949 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
950 |
class G1CMRootRegionScanTask : public AbstractGangTask { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
951 |
private: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
952 |
G1ConcurrentMark* _cm; |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
953 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
954 |
public: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
955 |
G1CMRootRegionScanTask(G1ConcurrentMark* cm) : |
38270
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
956 |
AbstractGangTask("G1 Root Region Scan"), _cm(cm) { } |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
957 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
958 |
void work(uint worker_id) { |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
959 |
assert(Thread::current()->is_ConcurrentGC_thread(), |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
960 |
"this should only be done by a conc GC thread"); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
961 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
962 |
G1CMRootRegions* root_regions = _cm->root_regions(); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
963 |
HeapRegion* hr = root_regions->claim_next(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
964 |
while (hr != NULL) { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
965 |
_cm->scanRootRegion(hr); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
966 |
hr = root_regions->claim_next(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
967 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
968 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
969 |
}; |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
970 |
|
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
971 |
void G1ConcurrentMark::scan_root_regions() { |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
972 |
// scan_in_progress() will have been set to true only if there was |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
973 |
// at least one root region to scan. So, if it's false, we |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
974 |
// should not attempt to do any further work. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
975 |
if (root_regions()->scan_in_progress()) { |
36084
9a3bf78e9a76
8148992: VM can hang on exit if root region scanning is initiated but not executed
brutisso
parents:
35943
diff
changeset
|
976 |
assert(!has_aborted(), "Aborting before root region scanning is finished not supported."); |
31397
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31346
diff
changeset
|
977 |
|
38270
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
978 |
_parallel_marking_threads = MIN2(calc_parallel_marking_threads(), |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
979 |
// We distribute work on a per-region basis, so starting |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
980 |
// more threads than that is useless. |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
981 |
root_regions()->num_root_regions()); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
982 |
assert(parallel_marking_threads() <= max_parallel_marking_threads(), |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
983 |
"Maximum number of marking threads exceeded"); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
984 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
985 |
G1CMRootRegionScanTask task(this); |
38270
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
986 |
log_debug(gc, ergo)("Running %s using %u workers for %u work units.", |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
987 |
task.name(), _parallel_marking_threads, root_regions()->num_root_regions()); |
2b3091f00fa0
8155810: Bound the number of root region scan threads to the number of survivor regions
tschatzl
parents:
38268
diff
changeset
|
988 |
_parallel_workers->run_task(&task, _parallel_marking_threads); |
11584
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
989 |
|
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
990 |
// It's possible that has_aborted() is true here without actually |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
991 |
// aborting the survivor scan earlier. This is OK as it's |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
992 |
// mainly used for sanity checking. |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
993 |
root_regions()->scan_finished(); |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
994 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
995 |
} |
e1df4d08a1f4
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
11583
diff
changeset
|
996 |
|
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
997 |
void G1ConcurrentMark::concurrent_cycle_start() { |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
998 |
_gc_timer_cm->register_gc_start(); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
999 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1000 |
_gc_tracer_cm->report_gc_start(GCCause::_no_gc /* first parameter is not used */, _gc_timer_cm->gc_start()); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1001 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1002 |
_g1h->trace_heap_before_gc(_gc_tracer_cm); |
35204 | 1003 |
} |
1004 |
||
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1005 |
void G1ConcurrentMark::concurrent_cycle_end() { |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1006 |
_g1h->trace_heap_after_gc(_gc_tracer_cm); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1007 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1008 |
if (has_aborted()) { |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1009 |
_gc_tracer_cm->report_concurrent_mode_failure(); |
36588
263860708cc6
8149834: gc/shared/gcTimer.cpp:88 assert(_is_concurrent_phase_active) failed: A concurrent phase is not active
sangheki
parents:
36387
diff
changeset
|
1010 |
} |
263860708cc6
8149834: gc/shared/gcTimer.cpp:88 assert(_is_concurrent_phase_active) failed: A concurrent phase is not active
sangheki
parents:
36387
diff
changeset
|
1011 |
|
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1012 |
_gc_timer_cm->register_gc_end(); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1013 |
|
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1014 |
_gc_tracer_cm->report_gc_end(_gc_timer_cm->gc_end(), _gc_timer_cm->time_partitions()); |
35204 | 1015 |
} |
1016 |
||
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
1017 |
void G1ConcurrentMark::mark_from_roots() { |
1374 | 1018 |
// we might be tempted to assert that: |
1019 |
// assert(asynch == !SafepointSynchronize::is_at_safepoint(), |
|
1020 |
// "inconsistent argument?"); |
|
1021 |
// However that wouldn't be right, because it's possible that |
|
1022 |
// a safepoint is indeed in progress as a younger generation |
|
1023 |
// stop-the-world GC happens even as we mark in this generation. |
|
1024 |
||
1025 |
_restart_for_overflow = false; |
|
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
1026 |
|
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
1027 |
// _g1h has _n_par_threads |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
1028 |
_parallel_marking_threads = calc_parallel_marking_threads(); |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
1029 |
assert(parallel_marking_threads() <= max_parallel_marking_threads(), |
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
1030 |
"Maximum number of marking threads exceeded"); |
11250 | 1031 |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1032 |
uint active_workers = MAX2(1U, parallel_marking_threads()); |
30875 | 1033 |
assert(active_workers > 0, "Should have been set"); |
11250 | 1034 |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1035 |
// Parallel task terminator is set in "set_concurrency_and_phase()" |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1036 |
set_concurrency_and_phase(active_workers, true /* concurrent */); |
1374 | 1037 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1038 |
G1CMConcurrentMarkingTask markingTask(this, cmThread()); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1039 |
_parallel_workers->set_active_workers(active_workers); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1040 |
_parallel_workers->run_task(&markingTask); |
1374 | 1041 |
print_stats(); |
1042 |
} |
|
1043 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1044 |
void G1ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) { |
1374 | 1045 |
// world is stopped at this checkpoint |
1046 |
assert(SafepointSynchronize::is_at_safepoint(), |
|
1047 |
"world should be stopped"); |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1048 |
|
1374 | 1049 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
1050 |
||
1051 |
// If a full collection has happened, we shouldn't do this. |
|
1052 |
if (has_aborted()) { |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
31330
diff
changeset
|
1053 |
g1h->collector_state()->set_mark_in_progress(false); // So bitmap clearing isn't confused |
1374 | 1054 |
return; |
1055 |
} |
|
1056 |
||
37235
d9a0c407ac98
8153302: [BACKOUT] STW phases at Concurrent GC should count in PerfCounter
dcubed
parents:
37218
diff
changeset
|
1057 |
SvcGCMarker sgcm(SvcGCMarker::OTHER); |
d9a0c407ac98
8153302: [BACKOUT] STW phases at Concurrent GC should count in PerfCounter
dcubed
parents:
37218
diff
changeset
|
1058 |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1059 |
if (VerifyDuringGC) { |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1060 |
HandleMark hm; // handle scope |
30173
13cf7580b000
8077413: Avoid use of Universe::heap() inside collectors
pliden
parents:
30158
diff
changeset
|
1061 |
g1h->prepare_for_verify(); |
35061 | 1062 |
Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (before)"); |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1063 |
} |
35851
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1064 |
g1h->verifier()->check_bitmaps("Remark Start"); |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1065 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37474
diff
changeset
|
1066 |
G1Policy* g1p = g1h->g1_policy(); |
1374 | 1067 |
g1p->record_concurrent_mark_remark_start(); |
1068 |
||
1069 |
double start = os::elapsedTime(); |
|
1070 |
||
1071 |
checkpointRootsFinalWork(); |
|
1072 |
||
1073 |
double mark_work_end = os::elapsedTime(); |
|
1074 |
||
1075 |
weakRefsWork(clear_all_soft_refs); |
|
1076 |
||
1077 |
if (has_overflown()) { |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1078 |
// We overflowed. Restart concurrent marking. |
1374 | 1079 |
_restart_for_overflow = true; |
16390
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1080 |
|
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1081 |
// Verify the heap w.r.t. the previous marking bitmap. |
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1082 |
if (VerifyDuringGC) { |
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1083 |
HandleMark hm; // handle scope |
30173
13cf7580b000
8077413: Avoid use of Universe::heap() inside collectors
pliden
parents:
30158
diff
changeset
|
1084 |
g1h->prepare_for_verify(); |
35061 | 1085 |
Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (overflow)"); |
16390
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1086 |
} |
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1087 |
|
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
1088 |
// Clear the marking state because we will be restarting |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
1089 |
// marking due to overflowing the global mark stack. |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
1090 |
reset_marking_state(); |
1374 | 1091 |
} else { |
7920 | 1092 |
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); |
1374 | 1093 |
// We're done with marking. |
5082
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
1094 |
// This is the end of the marking cycle, we're expected all |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
1095 |
// threads to have SATB queues with active set to true. |
7920 | 1096 |
satb_mq_set.set_active_all_threads(false, /* new active value */ |
1097 |
true /* expected_active */); |
|
3000 | 1098 |
|
1099 |
if (VerifyDuringGC) { |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1100 |
HandleMark hm; // handle scope |
30173
13cf7580b000
8077413: Avoid use of Universe::heap() inside collectors
pliden
parents:
30158
diff
changeset
|
1101 |
g1h->prepare_for_verify(); |
35061 | 1102 |
Universe::verify(VerifyOption_G1UseNextMarking, "During GC (after)"); |
3000 | 1103 |
} |
35851
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1104 |
g1h->verifier()->check_bitmaps("Remark End"); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1105 |
assert(!restart_for_overflow(), "sanity"); |
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
1106 |
// Completely reset the marking state since marking completed |
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
1107 |
set_non_marking_state(); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1108 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1109 |
|
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
1110 |
// Expand the marking stack, if we have to and if we can. |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1111 |
if (_global_mark_stack.should_expand()) { |
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1112 |
_global_mark_stack.expand(); |
14740
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
1113 |
} |
1431ef92fed1
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
14076
diff
changeset
|
1114 |
|
1374 | 1115 |
// Statistics |
1116 |
double now = os::elapsedTime(); |
|
1117 |
_remark_mark_times.add((mark_work_end - start) * 1000.0); |
|
1118 |
_remark_weak_ref_times.add((now - mark_work_end) * 1000.0); |
|
1119 |
_remark_times.add((now - start) * 1000.0); |
|
1120 |
||
1121 |
g1p->record_concurrent_mark_remark_end(); |
|
18025 | 1122 |
|
1123 |
G1CMIsAliveClosure is_alive(g1h); |
|
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1124 |
_gc_tracer_cm->report_object_count_after_gc(&is_alive); |
1374 | 1125 |
} |
1126 |
||
1127 |
class G1NoteEndOfConcMarkClosure : public HeapRegionClosure { |
|
1128 |
G1CollectedHeap* _g1; |
|
1129 |
size_t _freed_bytes; |
|
8072 | 1130 |
FreeRegionList* _local_cleanup_list; |
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1131 |
uint _old_regions_removed; |
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1132 |
uint _humongous_regions_removed; |
8072 | 1133 |
HRRSCleanupTask* _hrrs_cleanup_task; |
1374 | 1134 |
|
1135 |
public: |
|
1136 |
G1NoteEndOfConcMarkClosure(G1CollectedHeap* g1, |
|
8072 | 1137 |
FreeRegionList* local_cleanup_list, |
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1138 |
HRRSCleanupTask* hrrs_cleanup_task) : |
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23505
diff
changeset
|
1139 |
_g1(g1), |
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1140 |
_freed_bytes(0), |
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1141 |
_local_cleanup_list(local_cleanup_list), |
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1142 |
_old_regions_removed(0), |
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1143 |
_humongous_regions_removed(0), |
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1144 |
_hrrs_cleanup_task(hrrs_cleanup_task) { } |
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1145 |
|
1374 | 1146 |
size_t freed_bytes() { return _freed_bytes; } |
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1147 |
const uint old_regions_removed() { return _old_regions_removed; } |
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1148 |
const uint humongous_regions_removed() { return _humongous_regions_removed; } |
1374 | 1149 |
|
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1150 |
bool doHeapRegion(HeapRegion *hr) { |
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1151 |
if (hr->is_archive()) { |
13336
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13289
diff
changeset
|
1152 |
return false; |
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13289
diff
changeset
|
1153 |
} |
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13289
diff
changeset
|
1154 |
_g1->reset_gc_time_stamps(hr); |
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13289
diff
changeset
|
1155 |
hr->note_end_of_marking(); |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1156 |
|
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1157 |
if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) { |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1158 |
_freed_bytes += hr->used(); |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1159 |
hr->set_containing_set(NULL); |
26846
7d4376f8560e
8058495: G1: normalize names for isHumongous() and friends
tonyp
parents:
26841
diff
changeset
|
1160 |
if (hr->is_humongous()) { |
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1161 |
_humongous_regions_removed++; |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1162 |
_g1->free_humongous_region(hr, _local_cleanup_list, true); |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1163 |
} else { |
35065
b4ff0249c092
8144996: Replace the HeapRegionSetCount class with an uint
david
parents:
35061
diff
changeset
|
1164 |
_old_regions_removed++; |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1165 |
_g1->free_region(hr, _local_cleanup_list, true); |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1166 |
} |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1167 |
} else { |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1168 |
hr->rem_set()->do_cleanup_work(_hrrs_cleanup_task); |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1169 |
} |
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1170 |
|
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1171 |
return false; |
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1172 |
} |
1374 | 1173 |
}; |
1174 |
||
1175 |
class G1ParNoteEndTask: public AbstractGangTask { |
|
1176 |
friend class G1NoteEndOfConcMarkClosure; |
|
7923 | 1177 |
|
1374 | 1178 |
protected: |
1179 |
G1CollectedHeap* _g1h; |
|
7923 | 1180 |
FreeRegionList* _cleanup_list; |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26848
diff
changeset
|
1181 |
HeapRegionClaimer _hrclaimer; |
7923 | 1182 |
|
1374 | 1183 |
public: |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26848
diff
changeset
|
1184 |
G1ParNoteEndTask(G1CollectedHeap* g1h, FreeRegionList* cleanup_list, uint n_workers) : |
30884
6b4b41edd225
8081039: G1: Remove unused statistics code in G1NoteEndOfConcMarkClosure and G1ParNoteEndTask
brutisso
parents:
30876
diff
changeset
|
1185 |
AbstractGangTask("G1 note end"), _g1h(g1h), _cleanup_list(cleanup_list), _hrclaimer(n_workers) { |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26848
diff
changeset
|
1186 |
} |
1374 | 1187 |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1188 |
void work(uint worker_id) { |
8072 | 1189 |
FreeRegionList local_cleanup_list("Local Cleanup List"); |
1190 |
HRRSCleanupTask hrrs_cleanup_task; |
|
23855
c4574075402c
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
23505
diff
changeset
|
1191 |
G1NoteEndOfConcMarkClosure g1_note_end(_g1h, &local_cleanup_list, |
8072 | 1192 |
&hrrs_cleanup_task); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1193 |
_g1h->heap_region_par_iterate(&g1_note_end, worker_id, &_hrclaimer); |
1374 | 1194 |
assert(g1_note_end.complete(), "Shouldn't have yielded!"); |
1195 |
||
7923 | 1196 |
// Now update the lists |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1197 |
_g1h->remove_from_old_sets(g1_note_end.old_regions_removed(), g1_note_end.humongous_regions_removed()); |
1374 | 1198 |
{ |
1199 |
MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); |
|
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1200 |
_g1h->decrement_summary_bytes(g1_note_end.freed_bytes()); |
7923 | 1201 |
|
10001
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1202 |
// If we iterate over the global cleanup list at the end of |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1203 |
// cleanup to do this printing we will not guarantee to only |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1204 |
// generate output for the newly-reclaimed regions (the list |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1205 |
// might not be empty at the beginning of cleanup; we might |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1206 |
// still be working on its previous contents). So we do the |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1207 |
// printing here, before we append the new regions to the global |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1208 |
// cleanup list. |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1209 |
|
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1210 |
G1HRPrinter* hr_printer = _g1h->hr_printer(); |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1211 |
if (hr_printer->is_active()) { |
23450
c7c6202fc7e2
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
22551
diff
changeset
|
1212 |
FreeRegionListIterator iter(&local_cleanup_list); |
10001
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1213 |
while (iter.more_available()) { |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1214 |
HeapRegion* hr = iter.get_next(); |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1215 |
hr_printer->cleanup(hr); |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1216 |
} |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1217 |
} |
8aa7f885326e
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
9999
diff
changeset
|
1218 |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23463
diff
changeset
|
1219 |
_cleanup_list->add_ordered(&local_cleanup_list); |
8072 | 1220 |
assert(local_cleanup_list.is_empty(), "post-condition"); |
1221 |
||
1222 |
HeapRegionRemSet::finish_cleanup_task(&hrrs_cleanup_task); |
|
1374 | 1223 |
} |
1224 |
} |
|
1225 |
}; |
|
1226 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1227 |
void G1ConcurrentMark::cleanup() { |
1374 | 1228 |
// world is stopped at this checkpoint |
1229 |
assert(SafepointSynchronize::is_at_safepoint(), |
|
1230 |
"world should be stopped"); |
|
1231 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
1232 |
||
1233 |
// If a full collection has happened, we shouldn't do this. |
|
1234 |
if (has_aborted()) { |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
31330
diff
changeset
|
1235 |
g1h->collector_state()->set_mark_in_progress(false); // So bitmap clearing isn't confused |
1374 | 1236 |
return; |
1237 |
} |
|
1238 |
||
35851
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1239 |
g1h->verifier()->verify_region_sets_optional(); |
7923 | 1240 |
|
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1241 |
if (VerifyDuringGC) { |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1242 |
HandleMark hm; // handle scope |
30173
13cf7580b000
8077413: Avoid use of Universe::heap() inside collectors
pliden
parents:
30158
diff
changeset
|
1243 |
g1h->prepare_for_verify(); |
35061 | 1244 |
Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (before)"); |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1245 |
} |
35851
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1246 |
g1h->verifier()->check_bitmaps("Cleanup Start"); |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1247 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37474
diff
changeset
|
1248 |
G1Policy* g1p = g1h->g1_policy(); |
1374 | 1249 |
g1p->record_concurrent_mark_cleanup_start(); |
1250 |
||
1251 |
double start = os::elapsedTime(); |
|
1252 |
||
8072 | 1253 |
HeapRegionRemSet::reset_for_cleanup_tasks(); |
1254 |
||
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
1255 |
{ |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
1256 |
GCTraceTime(Debug, gc)("Finalize Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
1257 |
finalize_live_data(); |
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
1258 |
} |
1374 | 1259 |
|
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
1260 |
if (VerifyDuringGC) { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
1261 |
GCTraceTime(Debug, gc)("Verify Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
1262 |
verify_live_data(); |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
1263 |
} |
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
1264 |
|
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
31330
diff
changeset
|
1265 |
g1h->collector_state()->set_mark_in_progress(false); |
1374 | 1266 |
|
1267 |
double count_end = os::elapsedTime(); |
|
1268 |
double this_final_counting_time = (count_end - start); |
|
1269 |
_total_counting_time += this_final_counting_time; |
|
1270 |
||
35061 | 1271 |
if (log_is_enabled(Trace, gc, liveness)) { |
1272 |
G1PrintRegionLivenessInfoClosure cl("Post-Marking"); |
|
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
1273 |
_g1h->heap_region_iterate(&cl); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
1274 |
} |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
1275 |
|
1374 | 1276 |
// Install newly created mark bitMap as "prev". |
1277 |
swapMarkBitMaps(); |
|
1278 |
||
1279 |
g1h->reset_gc_time_stamp(); |
|
1280 |
||
30871 | 1281 |
uint n_workers = _g1h->workers()->active_workers(); |
1282 |
||
1374 | 1283 |
// Note end of marking in all heap regions. |
27009
e7e723732b6b
8058298: Separate heap region iterator claim values from the data structures iterated over
mlarsson
parents:
26848
diff
changeset
|
1284 |
G1ParNoteEndTask g1_par_note_end_task(g1h, &_cleanup_list, n_workers); |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1285 |
g1h->workers()->run_task(&g1_par_note_end_task); |
13336
e582172ff6ff
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
13289
diff
changeset
|
1286 |
g1h->check_gc_time_stamps(); |
7923 | 1287 |
|
1288 |
if (!cleanup_list_is_empty()) { |
|
1289 |
// The cleanup list is not empty, so we'll have to process it |
|
1290 |
// concurrently. Notify anyone else that might be wanting free |
|
1291 |
// regions that there will be more free regions coming soon. |
|
1292 |
g1h->set_free_regions_coming(); |
|
1293 |
} |
|
1374 | 1294 |
|
1295 |
// call below, since it affects the metric by which we sort the heap |
|
1296 |
// regions. |
|
1297 |
if (G1ScrubRemSets) { |
|
1298 |
double rs_scrub_start = os::elapsedTime(); |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
1299 |
g1h->scrub_rem_set(); |
35211
3771329165d4
8145774: Move scrubbing setup code away out of ConcurrentMark
tschatzl
parents:
35204
diff
changeset
|
1300 |
_total_rs_scrub_time += (os::elapsedTime() - rs_scrub_start); |
1374 | 1301 |
} |
1302 |
||
1303 |
// this will also free any regions totally full of garbage objects, |
|
1304 |
// and sort the regions. |
|
30874
18714bae50db
8080837: Move number of workers calculation out of CollectionSetChooser::prepare_for_par_region_addition
stefank
parents:
30871
diff
changeset
|
1305 |
g1h->g1_policy()->record_concurrent_mark_cleanup_end(); |
1374 | 1306 |
|
1307 |
// Statistics. |
|
1308 |
double end = os::elapsedTime(); |
|
1309 |
_cleanup_times.add((end - start) * 1000.0); |
|
1310 |
||
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1311 |
// Clean up will have freed any regions completely full of garbage. |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1312 |
// Update the soft reference policy with the new heap occupancy. |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1313 |
Universe::update_heap_info_at_gc(); |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1314 |
|
2741 | 1315 |
if (VerifyDuringGC) { |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
3184
diff
changeset
|
1316 |
HandleMark hm; // handle scope |
30173
13cf7580b000
8077413: Avoid use of Universe::heap() inside collectors
pliden
parents:
30158
diff
changeset
|
1317 |
g1h->prepare_for_verify(); |
35061 | 1318 |
Universe::verify(VerifyOption_G1UsePrevMarking, "During GC (after)"); |
1374 | 1319 |
} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1320 |
|
35851
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1321 |
g1h->verifier()->check_bitmaps("Cleanup End"); |
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1322 |
|
5451ff646f8e
8147814: Move verification code out of g1collectedheap
david
parents:
35211
diff
changeset
|
1323 |
g1h->verifier()->verify_region_sets_optional(); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1324 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1325 |
// We need to make this be a "collection" so any collection pause that |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1326 |
// races with it goes around and waits for completeCleanup to finish. |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1327 |
g1h->increment_total_collections(); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1328 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1329 |
// Clean out dead classes and update Metaspace sizes. |
25908
8adb2fb6fc3c
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
25893
diff
changeset
|
1330 |
if (ClassUnloadingWithConcurrentMark) { |
8adb2fb6fc3c
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
25893
diff
changeset
|
1331 |
ClassLoaderDataGraph::purge(); |
8adb2fb6fc3c
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
25893
diff
changeset
|
1332 |
} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1333 |
MetaspaceGC::compute_new_size(); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1334 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1335 |
// We reclaimed old regions so we should calculate the sizes to make |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1336 |
// sure we update the old gen/space data. |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1337 |
g1h->g1mm()->update_sizes(); |
27897
253140db0e9a
8065227: Report allocation context stats at end of cleanup
sjohanss
parents:
27885
diff
changeset
|
1338 |
g1h->allocation_context_stats().update_after_mark(); |
1374 | 1339 |
} |
1340 |
||
37123
bf4f064a10a8
8151614: Improve logging in concurrent mark code
tschatzl
parents:
37122
diff
changeset
|
1341 |
void G1ConcurrentMark::complete_cleanup() { |
1374 | 1342 |
if (has_aborted()) return; |
1343 |
||
7923 | 1344 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
1345 |
||
23857
f00e672a0531
8039089: List verification enabled in product builds
jwilhelm
parents:
23855
diff
changeset
|
1346 |
_cleanup_list.verify_optional(); |
8680 | 1347 |
FreeRegionList tmp_free_list("Tmp Free List"); |
7923 | 1348 |
|
35061 | 1349 |
log_develop_trace(gc, freelist)("G1ConcRegionFreeing [complete cleanup] : " |
1350 |
"cleanup list has %u entries", |
|
1351 |
_cleanup_list.length()); |
|
7923 | 1352 |
|
26160 | 1353 |
// No one else should be accessing the _cleanup_list at this point, |
1354 |
// so it is not necessary to take any locks |
|
7923 | 1355 |
while (!_cleanup_list.is_empty()) { |
26157
70eddb655686
8054818: Refactor HeapRegionSeq to manage heap region and auxiliary data
tschatzl
parents:
25908
diff
changeset
|
1356 |
HeapRegion* hr = _cleanup_list.remove_region(true /* from_head */); |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23463
diff
changeset
|
1357 |
assert(hr != NULL, "Got NULL from a non-empty list"); |
9418
32a87dd6b746
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
9417
diff
changeset
|
1358 |
hr->par_clear(); |
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23463
diff
changeset
|
1359 |
tmp_free_list.add_ordered(hr); |
7923 | 1360 |
|
1361 |
// Instead of adding one region at a time to the secondary_free_list, |
|
1362 |
// we accumulate them in the local list and move them a few at a |
|
1363 |
// time. This also cuts down on the number of notify_all() calls |
|
1364 |
// we do during this process. We'll also append the local list when |
|
1365 |
// _cleanup_list is empty (which means we just removed the last |
|
1366 |
// region from the _cleanup_list). |
|
8680 | 1367 |
if ((tmp_free_list.length() % G1SecondaryFreeListAppendLength == 0) || |
7923 | 1368 |
_cleanup_list.is_empty()) { |
35061 | 1369 |
log_develop_trace(gc, freelist)("G1ConcRegionFreeing [complete cleanup] : " |
1370 |
"appending %u entries to the secondary_free_list, " |
|
1371 |
"cleanup list still has %u entries", |
|
1372 |
tmp_free_list.length(), |
|
1373 |
_cleanup_list.length()); |
|
7923 | 1374 |
|
1375 |
{ |
|
1376 |
MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
|
23471
ec9427262f0a
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
23463
diff
changeset
|
1377 |
g1h->secondary_free_list_add(&tmp_free_list); |
7923 | 1378 |
SecondaryFreeList_lock->notify_all(); |
1379 |
} |
|
29580
a67a581cfe11
8073315: Enable gcc -Wtype-limits and fix upcoming issues.
goetz
parents:
29472
diff
changeset
|
1380 |
#ifndef PRODUCT |
7923 | 1381 |
if (G1StressConcRegionFreeing) { |
1382 |
for (uintx i = 0; i < G1StressConcRegionFreeingDelayMillis; ++i) { |
|
1383 |
os::sleep(Thread::current(), (jlong) 1, false); |
|
1384 |
} |
|
1385 |
} |
|
29580
a67a581cfe11
8073315: Enable gcc -Wtype-limits and fix upcoming issues.
goetz
parents:
29472
diff
changeset
|
1386 |
#endif |
1374 | 1387 |
} |
1388 |
} |
|
8680 | 1389 |
assert(tmp_free_list.is_empty(), "post-condition"); |
1374 | 1390 |
} |
1391 |
||
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1392 |
// Supporting Object and Oop closures for reference discovery |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1393 |
// and processing in during marking |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1394 |
|
7657
a80e571c3d96
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
7399
diff
changeset
|
1395 |
bool G1CMIsAliveClosure::do_object_b(oop obj) { |
a80e571c3d96
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
7399
diff
changeset
|
1396 |
HeapWord* addr = (HeapWord*)obj; |
a80e571c3d96
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
7399
diff
changeset
|
1397 |
return addr != NULL && |
a80e571c3d96
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
7399
diff
changeset
|
1398 |
(!_g1->is_in_g1_reserved(addr) || !_g1->is_obj_ill(obj)); |
a80e571c3d96
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
7399
diff
changeset
|
1399 |
} |
1374 | 1400 |
|
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1401 |
// 'Keep Alive' oop closure used by both serial parallel reference processing. |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1402 |
// Uses the G1CMTask associated with a worker thread (for serial reference |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1403 |
// processing the G1CMTask for worker 0 is used) to preserve (mark) and |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1404 |
// trace referent objects. |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1405 |
// |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1406 |
// Using the G1CMTask and embedded local queues avoids having the worker |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1407 |
// threads operating on the global mark stack. This reduces the risk |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1408 |
// of overflowing the stack - which we would rather avoid at this late |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1409 |
// state. Also using the tasks' local queues removes the potential |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1410 |
// of the workers interfering with each other that could occur if |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1411 |
// operating on the global stack. |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1412 |
|
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1413 |
class G1CMKeepAliveAndDrainClosure: public OopClosure { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1414 |
G1ConcurrentMark* _cm; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1415 |
G1CMTask* _task; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1416 |
int _ref_counter_limit; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1417 |
int _ref_counter; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1418 |
bool _is_serial; |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1419 |
public: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1420 |
G1CMKeepAliveAndDrainClosure(G1ConcurrentMark* cm, G1CMTask* task, bool is_serial) : |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1421 |
_cm(cm), _task(task), _is_serial(is_serial), |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1422 |
_ref_counter_limit(G1RefProcDrainInterval) { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1423 |
assert(_ref_counter_limit > 0, "sanity"); |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1424 |
assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code"); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1425 |
_ref_counter = _ref_counter_limit; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1426 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1427 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1428 |
virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1429 |
virtual void do_oop( oop* p) { do_oop_work(p); } |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1430 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1431 |
template <class T> void do_oop_work(T* p) { |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1432 |
if (!_cm->has_overflown()) { |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1433 |
oop obj = oopDesc::load_decode_heap_oop(p); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1434 |
_task->deal_with_reference(obj); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1435 |
_ref_counter--; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1436 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1437 |
if (_ref_counter == 0) { |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1438 |
// We have dealt with _ref_counter_limit references, pushing them |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1439 |
// and objects reachable from them on to the local stack (and |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1440 |
// possibly the global stack). Call G1CMTask::do_marking_step() to |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1441 |
// process these entries. |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1442 |
// |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1443 |
// We call G1CMTask::do_marking_step() in a loop, which we'll exit if |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1444 |
// there's nothing more to do (i.e. we're done with the entries that |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1445 |
// were pushed as a result of the G1CMTask::deal_with_reference() calls |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1446 |
// above) or we overflow. |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1447 |
// |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1448 |
// Note: G1CMTask::do_marking_step() can set the G1CMTask::has_aborted() |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1449 |
// flag while there may still be some work to do. (See the comment at |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1450 |
// the beginning of G1CMTask::do_marking_step() for those conditions - |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1451 |
// one of which is reaching the specified time target.) It is only |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1452 |
// when G1CMTask::do_marking_step() returns without setting the |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1453 |
// has_aborted() flag that the marking step has completed. |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1454 |
do { |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1455 |
double mark_step_duration_ms = G1ConcMarkStepDurationMillis; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1456 |
_task->do_marking_step(mark_step_duration_ms, |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1457 |
false /* do_termination */, |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1458 |
_is_serial); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1459 |
} while (_task->has_aborted() && !_cm->has_overflown()); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1460 |
_ref_counter = _ref_counter_limit; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1461 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1462 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1463 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1464 |
}; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1465 |
|
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1466 |
// 'Drain' oop closure used by both serial and parallel reference processing. |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1467 |
// Uses the G1CMTask associated with a given worker thread (for serial |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1468 |
// reference processing the G1CMtask for worker 0 is used). Calls the |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1469 |
// do_marking_step routine, with an unbelievably large timeout value, |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1470 |
// to drain the marking data structures of the remaining entries |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1471 |
// added by the 'keep alive' oop closure above. |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1472 |
|
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1473 |
class G1CMDrainMarkingStackClosure: public VoidClosure { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1474 |
G1ConcurrentMark* _cm; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1475 |
G1CMTask* _task; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1476 |
bool _is_serial; |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1477 |
public: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1478 |
G1CMDrainMarkingStackClosure(G1ConcurrentMark* cm, G1CMTask* task, bool is_serial) : |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1479 |
_cm(cm), _task(task), _is_serial(is_serial) { |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1480 |
assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code"); |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1481 |
} |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1482 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1483 |
void do_void() { |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1484 |
do { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1485 |
// We call G1CMTask::do_marking_step() to completely drain the local |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1486 |
// and global marking stacks of entries pushed by the 'keep alive' |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1487 |
// oop closure (an instance of G1CMKeepAliveAndDrainClosure above). |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1488 |
// |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1489 |
// G1CMTask::do_marking_step() is called in a loop, which we'll exit |
22551 | 1490 |
// if there's nothing more to do (i.e. we've completely drained the |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1491 |
// entries that were pushed as a a result of applying the 'keep alive' |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1492 |
// closure to the entries on the discovered ref lists) or we overflow |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1493 |
// the global marking stack. |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1494 |
// |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1495 |
// Note: G1CMTask::do_marking_step() can set the G1CMTask::has_aborted() |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1496 |
// flag while there may still be some work to do. (See the comment at |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1497 |
// the beginning of G1CMTask::do_marking_step() for those conditions - |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1498 |
// one of which is reaching the specified time target.) It is only |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1499 |
// when G1CMTask::do_marking_step() returns without setting the |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1500 |
// has_aborted() flag that the marking step has completed. |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1501 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1502 |
_task->do_marking_step(1000000000.0 /* something very large */, |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1503 |
true /* do_termination */, |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1504 |
_is_serial); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1505 |
} while (_task->has_aborted() && !_cm->has_overflown()); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1506 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1507 |
}; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1508 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1509 |
// Implementation of AbstractRefProcTaskExecutor for parallel |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1510 |
// reference processing at the end of G1 concurrent marking |
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1511 |
|
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1512 |
class G1CMRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1513 |
private: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1514 |
G1CollectedHeap* _g1h; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1515 |
G1ConcurrentMark* _cm; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1516 |
WorkGang* _workers; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1517 |
uint _active_workers; |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1518 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1519 |
public: |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1520 |
G1CMRefProcTaskExecutor(G1CollectedHeap* g1h, |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1521 |
G1ConcurrentMark* cm, |
30585 | 1522 |
WorkGang* workers, |
1523 |
uint n_workers) : |
|
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1524 |
_g1h(g1h), _cm(cm), |
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1525 |
_workers(workers), _active_workers(n_workers) { } |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1526 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1527 |
// Executes the given task using concurrent marking worker threads. |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1528 |
virtual void execute(ProcessTask& task); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1529 |
virtual void execute(EnqueueTask& task); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1530 |
}; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1531 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1532 |
class G1CMRefProcTaskProxy: public AbstractGangTask { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1533 |
typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1534 |
ProcessTask& _proc_task; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1535 |
G1CollectedHeap* _g1h; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1536 |
G1ConcurrentMark* _cm; |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1537 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1538 |
public: |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1539 |
G1CMRefProcTaskProxy(ProcessTask& proc_task, |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1540 |
G1CollectedHeap* g1h, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1541 |
G1ConcurrentMark* cm) : |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1542 |
AbstractGangTask("Process reference objects in parallel"), |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1543 |
_proc_task(proc_task), _g1h(g1h), _cm(cm) { |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1544 |
ReferenceProcessor* rp = _g1h->ref_processor_cm(); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1545 |
assert(rp->processing_is_mt(), "shouldn't be here otherwise"); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1546 |
} |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1547 |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1548 |
virtual void work(uint worker_id) { |
25893
b4141bec6a67
8050973: CMS/G1 GC: add missing Resource and Handle mark
mdoerr
parents:
25728
diff
changeset
|
1549 |
ResourceMark rm; |
b4141bec6a67
8050973: CMS/G1 GC: add missing Resource and Handle mark
mdoerr
parents:
25728
diff
changeset
|
1550 |
HandleMark hm; |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1551 |
G1CMTask* task = _cm->task(worker_id); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1552 |
G1CMIsAliveClosure g1_is_alive(_g1h); |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1553 |
G1CMKeepAliveAndDrainClosure g1_par_keep_alive(_cm, task, false /* is_serial */); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1554 |
G1CMDrainMarkingStackClosure g1_par_drain(_cm, task, false /* is_serial */); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1555 |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1556 |
_proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, g1_par_drain); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1557 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1558 |
}; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1559 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1560 |
void G1CMRefProcTaskExecutor::execute(ProcessTask& proc_task) { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1561 |
assert(_workers != NULL, "Need parallel worker threads."); |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1562 |
assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT"); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1563 |
|
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1564 |
G1CMRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _cm); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1565 |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1566 |
// We need to reset the concurrency level before each |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1567 |
// proxy task execution, so that the termination protocol |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1568 |
// and overflow handling in G1CMTask::do_marking_step() knows |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1569 |
// how many workers to wait for. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1570 |
_cm->set_concurrency(_active_workers); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1571 |
_workers->run_task(&proc_task_proxy); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1572 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1573 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1574 |
class G1CMRefEnqueueTaskProxy: public AbstractGangTask { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1575 |
typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1576 |
EnqueueTask& _enq_task; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1577 |
|
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1578 |
public: |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1579 |
G1CMRefEnqueueTaskProxy(EnqueueTask& enq_task) : |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1580 |
AbstractGangTask("Enqueue reference objects in parallel"), |
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1581 |
_enq_task(enq_task) { } |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1582 |
|
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1583 |
virtual void work(uint worker_id) { |
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1584 |
_enq_task.work(worker_id); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1585 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1586 |
}; |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1587 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1588 |
void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1589 |
assert(_workers != NULL, "Need parallel worker threads."); |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1590 |
assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT"); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1591 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1592 |
G1CMRefEnqueueTaskProxy enq_task_proxy(enq_task); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1593 |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1594 |
// Not strictly necessary but... |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1595 |
// |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1596 |
// We need to reset the concurrency level before each |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1597 |
// proxy task execution, so that the termination protocol |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1598 |
// and overflow handling in G1CMTask::do_marking_step() knows |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1599 |
// how many workers to wait for. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1600 |
_cm->set_concurrency(_active_workers); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1601 |
_workers->run_task(&enq_task_proxy); |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1602 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1603 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1604 |
void G1ConcurrentMark::weakRefsWorkParallelPart(BoolObjectClosure* is_alive, bool purged_classes) { |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1605 |
G1CollectedHeap::heap()->parallel_cleaning(is_alive, true, true, purged_classes); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1606 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1607 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1608 |
void G1ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) { |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1609 |
if (has_overflown()) { |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1610 |
// Skip processing the discovered references if we have |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1611 |
// overflown the global marking stack. Reference objects |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1612 |
// only get discovered once so it is OK to not |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1613 |
// de-populate the discovered reference lists. We could have, |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1614 |
// but the only benefit would be that, when marking restarts, |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1615 |
// less reference objects are discovered. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1616 |
return; |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1617 |
} |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1618 |
|
1374 | 1619 |
ResourceMark rm; |
1620 |
HandleMark hm; |
|
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1621 |
|
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1622 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1623 |
|
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1624 |
// Is alive closure. |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1625 |
G1CMIsAliveClosure g1_is_alive(g1h); |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1626 |
|
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1627 |
// Inner scope to exclude the cleaning of the string and symbol |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1628 |
// tables from the displayed time. |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1629 |
{ |
37146 | 1630 |
GCTraceTime(Debug, gc, phases) trace("Reference Processing", _gc_timer_cm); |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1631 |
|
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1632 |
ReferenceProcessor* rp = g1h->ref_processor_cm(); |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1633 |
|
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1634 |
// See the comment in G1CollectedHeap::ref_processing_init() |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1635 |
// about how reference processing currently works in G1. |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1636 |
|
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1637 |
// Set the soft reference policy |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1638 |
rp->setup_policy(clear_all_soft_refs); |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1639 |
assert(_global_mark_stack.is_empty(), "mark stack should be empty"); |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1640 |
|
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1641 |
// Instances of the 'Keep Alive' and 'Complete GC' closures used |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1642 |
// in serial reference processing. Note these closures are also |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1643 |
// used for serially processing (by the the current thread) the |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1644 |
// JNI references during parallel reference processing. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1645 |
// |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1646 |
// These closures do not need to synchronize with the worker |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1647 |
// threads involved in parallel reference processing as these |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1648 |
// instances are executed serially by the current thread (e.g. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1649 |
// reference processing is not multi-threaded and is thus |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1650 |
// performed by the current thread instead of a gang worker). |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1651 |
// |
22551 | 1652 |
// The gang tasks involved in parallel reference processing create |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1653 |
// their own instances of these closures, which do their own |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1654 |
// synchronization among themselves. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1655 |
G1CMKeepAliveAndDrainClosure g1_keep_alive(this, task(0), true /* is_serial */); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1656 |
G1CMDrainMarkingStackClosure g1_drain_mark_stack(this, task(0), true /* is_serial */); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1657 |
|
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1658 |
// We need at least one active thread. If reference processing |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1659 |
// is not multi-threaded we use the current (VMThread) thread, |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1660 |
// otherwise we use the work gang from the G1CollectedHeap and |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1661 |
// we utilize all the worker threads we can. |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1662 |
bool processing_is_mt = rp->processing_is_mt(); |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1663 |
uint active_workers = (processing_is_mt ? g1h->workers()->active_workers() : 1U); |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
1664 |
active_workers = MAX2(MIN2(active_workers, _max_worker_id), 1U); |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1665 |
|
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1666 |
// Parallel processing task executor. |
11172
f720721985ba
7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents:
10996
diff
changeset
|
1667 |
G1CMRefProcTaskExecutor par_task_executor(g1h, this, |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1668 |
g1h->workers(), active_workers); |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1669 |
AbstractRefProcTaskExecutor* executor = (processing_is_mt ? &par_task_executor : NULL); |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1670 |
|
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1671 |
// Set the concurrency level. The phase was already set prior to |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1672 |
// executing the remark task. |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1673 |
set_concurrency(active_workers); |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
1674 |
|
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1675 |
// Set the degree of MT processing here. If the discovery was done MT, |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1676 |
// the number of threads involved during discovery could differ from |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1677 |
// the number of active workers. This is OK as long as the discovered |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1678 |
// Reference lists are balanced (see balance_all_queues() and balance_queues()). |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1679 |
rp->set_active_mt_degree(active_workers); |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1680 |
|
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1681 |
// Process the weak references. |
18025 | 1682 |
const ReferenceProcessorStats& stats = |
1683 |
rp->process_discovered_references(&g1_is_alive, |
|
1684 |
&g1_keep_alive, |
|
1685 |
&g1_drain_mark_stack, |
|
1686 |
executor, |
|
37137
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1687 |
_gc_timer_cm); |
62fd3fb4b1b1
8151085: Change G1 concurrent timer and tracer measuring time
sangheki
parents:
37130
diff
changeset
|
1688 |
_gc_tracer_cm->report_gc_reference_stats(stats); |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1689 |
|
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1690 |
// The do_oop work routines of the keep_alive and drain_marking_stack |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1691 |
// oop closures will set the has_overflown flag if we overflow the |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1692 |
// global marking stack. |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1693 |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1694 |
assert(_global_mark_stack.overflow() || _global_mark_stack.is_empty(), |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1695 |
"mark stack should be empty (unless it overflowed)"); |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1696 |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1697 |
if (_global_mark_stack.overflow()) { |
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1698 |
// This should have been done already when we tried to push an |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1699 |
// entry on to the global mark stack. But let's do it again. |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1700 |
set_has_overflown(); |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1701 |
} |
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1702 |
|
15495
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1703 |
assert(rp->num_q() == active_workers, "why not"); |
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1704 |
|
d791a8e8cf6b
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
15489
diff
changeset
|
1705 |
rp->enqueue_discovered_references(executor); |
10666
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1706 |
|
1fd33ec0e5f7
7068215: G1: Print reference processing time during remark
johnc
parents:
10523
diff
changeset
|
1707 |
rp->verify_no_references_recorded(); |
10670
4ea0e7d2ffbc
6484982: G1: process references during evacuation pauses
johnc
parents:
10668
diff
changeset
|
1708 |
assert(!rp->discovery_enabled(), "Post condition"); |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1709 |
} |
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1710 |
|
23463
8a9ab140068a
8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents:
23450
diff
changeset
|
1711 |
if (has_overflown()) { |
8a9ab140068a
8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents:
23450
diff
changeset
|
1712 |
// We can not trust g1_is_alive if the marking stack overflowed |
8a9ab140068a
8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents:
23450
diff
changeset
|
1713 |
return; |
8a9ab140068a
8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents:
23450
diff
changeset
|
1714 |
} |
8a9ab140068a
8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents:
23450
diff
changeset
|
1715 |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1716 |
assert(_global_mark_stack.is_empty(), "Marking should have completed"); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1717 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1718 |
// Unload Klasses, String, Symbols, Code Cache, etc. |
37146 | 1719 |
if (ClassUnloadingWithConcurrentMark) { |
1720 |
bool purged_classes; |
|
1721 |
||
1722 |
{ |
|
1723 |
GCTraceTime(Debug, gc, phases) trace("System Dictionary Unloading", _gc_timer_cm); |
|
1724 |
purged_classes = SystemDictionary::do_unloading(&g1_is_alive, false /* Defer klass cleaning */); |
|
25908
8adb2fb6fc3c
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
25893
diff
changeset
|
1725 |
} |
8adb2fb6fc3c
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
25893
diff
changeset
|
1726 |
|
37146 | 1727 |
{ |
1728 |
GCTraceTime(Debug, gc, phases) trace("Parallel Unloading", _gc_timer_cm); |
|
1729 |
weakRefsWorkParallelPart(&g1_is_alive, purged_classes); |
|
25908
8adb2fb6fc3c
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
25893
diff
changeset
|
1730 |
} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1731 |
} |
37146 | 1732 |
|
1733 |
if (G1StringDedup::is_enabled()) { |
|
1734 |
GCTraceTime(Debug, gc, phases) trace("String Deduplication Unlink", _gc_timer_cm); |
|
1735 |
G1StringDedup::unlink(&g1_is_alive); |
|
1736 |
} |
|
1374 | 1737 |
} |
1738 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1739 |
void G1ConcurrentMark::swapMarkBitMaps() { |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1740 |
G1CMBitMapRO* temp = _prevMarkBitMap; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1741 |
_prevMarkBitMap = (G1CMBitMapRO*)_nextMarkBitMap; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1742 |
_nextMarkBitMap = (G1CMBitMap*) temp; |
1374 | 1743 |
} |
1744 |
||
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1745 |
// Closure for marking entries in SATB buffers. |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1746 |
class G1CMSATBBufferClosure : public SATBBufferClosure { |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1747 |
private: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1748 |
G1CMTask* _task; |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1749 |
G1CollectedHeap* _g1h; |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1750 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1751 |
// This is very similar to G1CMTask::deal_with_reference, but with |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1752 |
// more relaxed requirements for the argument, so this must be more |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1753 |
// circumspect about treating the argument as an object. |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1754 |
void do_entry(void* entry) const { |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1755 |
_task->increment_refs_reached(); |
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1756 |
HeapRegion* hr = _g1h->heap_region_containing(entry); |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1757 |
if (entry < hr->next_top_at_mark_start()) { |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1758 |
// Until we get here, we don't know whether entry refers to a valid |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1759 |
// object; it could instead have been a stale reference. |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1760 |
oop obj = static_cast<oop>(entry); |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1761 |
assert(obj->is_oop(true /* ignore mark word */), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1762 |
"Invalid oop in SATB buffer: " PTR_FORMAT, p2i(obj)); |
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
1763 |
_task->make_reference_grey(obj); |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1764 |
} |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1765 |
} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1766 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1767 |
public: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1768 |
G1CMSATBBufferClosure(G1CMTask* task, G1CollectedHeap* g1h) |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1769 |
: _task(task), _g1h(g1h) { } |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1770 |
|
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1771 |
virtual void do_buffer(void** buffer, size_t size) { |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1772 |
for (size_t i = 0; i < size; ++i) { |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1773 |
do_entry(buffer[i]); |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1774 |
} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1775 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1776 |
}; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1777 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1778 |
class G1RemarkThreadsClosure : public ThreadClosure { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1779 |
G1CMSATBBufferClosure _cm_satb_cl; |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1780 |
G1CMOopClosure _cm_cl; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1781 |
MarkingCodeBlobClosure _code_cl; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1782 |
int _thread_parity; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1783 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1784 |
public: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1785 |
G1RemarkThreadsClosure(G1CollectedHeap* g1h, G1CMTask* task) : |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1786 |
_cm_satb_cl(task, g1h), |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1787 |
_cm_cl(g1h, g1h->concurrent_mark(), task), |
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1788 |
_code_cl(&_cm_cl, !CodeBlobToOopClosure::FixRelocations), |
29802
d485440c958a
8076225: Move the thread claim parity from SharedHeap to Thread
mgerdin
parents:
29795
diff
changeset
|
1789 |
_thread_parity(Threads::thread_claim_parity()) {} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1790 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1791 |
void do_thread(Thread* thread) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1792 |
if (thread->is_Java_thread()) { |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1793 |
if (thread->claim_oops_do(true, _thread_parity)) { |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1794 |
JavaThread* jt = (JavaThread*)thread; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1795 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1796 |
// In theory it should not be neccessary to explicitly walk the nmethods to find roots for concurrent marking |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1797 |
// however the liveness of oops reachable from nmethods have very complex lifecycles: |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1798 |
// * Alive if on the stack of an executing method |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1799 |
// * Weakly reachable otherwise |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1800 |
// Some objects reachable from nmethods, such as the class loader (or klass_holder) of the receiver should be |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1801 |
// live by the SATB invariant but other oops recorded in nmethods may behave differently. |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1802 |
jt->nmethods_do(&_code_cl); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1803 |
|
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1804 |
jt->satb_mark_queue().apply_closure_and_empty(&_cm_satb_cl); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1805 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1806 |
} else if (thread->is_VM_thread()) { |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1807 |
if (thread->claim_oops_do(true, _thread_parity)) { |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
1808 |
JavaThread::satb_mark_queue_set().shared_satb_queue()->apply_closure_and_empty(&_cm_satb_cl); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1809 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1810 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1811 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1812 |
}; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1813 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1814 |
class G1CMRemarkTask: public AbstractGangTask { |
1374 | 1815 |
private: |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1816 |
G1ConcurrentMark* _cm; |
1374 | 1817 |
public: |
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1818 |
void work(uint worker_id) { |
1374 | 1819 |
// Since all available tasks are actually started, we should |
22551 | 1820 |
// only proceed if we're supposed to be active. |
11396
917d8673b5ef
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
11250
diff
changeset
|
1821 |
if (worker_id < _cm->active_tasks()) { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1822 |
G1CMTask* task = _cm->task(worker_id); |
1374 | 1823 |
task->record_start_time(); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1824 |
{ |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1825 |
ResourceMark rm; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1826 |
HandleMark hm; |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1827 |
|
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1828 |
G1RemarkThreadsClosure threads_f(G1CollectedHeap::heap(), task); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1829 |
Threads::threads_do(&threads_f); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1830 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1831 |
|
1374 | 1832 |
do { |
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
1833 |
task->do_marking_step(1000000000.0 /* something very large */, |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
1834 |
true /* do_termination */, |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1835 |
false /* is_serial */); |
1374 | 1836 |
} while (task->has_aborted() && !_cm->has_overflown()); |
1837 |
// If we overflow, then we do not want to restart. We instead |
|
1838 |
// want to abort remark and do concurrent marking again. |
|
1839 |
task->record_end_time(); |
|
1840 |
} |
|
1841 |
} |
|
1842 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1843 |
G1CMRemarkTask(G1ConcurrentMark* cm, uint active_workers) : |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1844 |
AbstractGangTask("Par Remark"), _cm(cm) { |
11250 | 1845 |
_cm->terminator()->reset_for_reuse(active_workers); |
11174
fccee5238e70
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
11172
diff
changeset
|
1846 |
} |
1374 | 1847 |
}; |
1848 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1849 |
void G1ConcurrentMark::checkpointRootsFinalWork() { |
1374 | 1850 |
ResourceMark rm; |
1851 |
HandleMark hm; |
|
1852 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
1853 |
||
37146 | 1854 |
GCTraceTime(Debug, gc, phases) trace("Finalize Marking", _gc_timer_cm); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1855 |
|
1374 | 1856 |
g1h->ensure_parsability(false); |
1857 |
||
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1858 |
// this is remark, so we'll use up all active threads |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1859 |
uint active_workers = g1h->workers()->active_workers(); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1860 |
set_concurrency_and_phase(active_workers, false /* concurrent */); |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1861 |
// Leave _parallel_marking_threads at it's |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1862 |
// value originally calculated in the G1ConcurrentMark |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1863 |
// constructor and pass values of the active workers |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1864 |
// through the gang in the task. |
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1865 |
|
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1866 |
{ |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1867 |
StrongRootsScope srs(active_workers); |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1868 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1869 |
G1CMRemarkTask remarkTask(this, active_workers); |
30868
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1870 |
// We will start all available threads, even if we decide that the |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1871 |
// active_workers will be fewer. The extra ones will just bail out |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1872 |
// immediately. |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1873 |
g1h->workers()->run_task(&remarkTask); |
c1b24f26deed
8080110: Remove usage of CollectedHeap::n_par_threads() from root processing
stefank
parents:
30770
diff
changeset
|
1874 |
} |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
1875 |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
1876 |
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); |
16390
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1877 |
guarantee(has_overflown() || |
848861a059be
8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents:
16389
diff
changeset
|
1878 |
satb_mq_set.completed_buffers_num() == 0, |
36371
fd81a4f0ea00
8139651: ConcurrentG1Refine uses ints for many of its members that should be unsigned types
jprovino
parents:
36191
diff
changeset
|
1879 |
"Invariant: has_overflown = %s, num buffers = " SIZE_FORMAT, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1880 |
BOOL_TO_STR(has_overflown()), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1881 |
satb_mq_set.completed_buffers_num()); |
1374 | 1882 |
|
1883 |
print_stats(); |
|
1884 |
} |
|
1885 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1886 |
void G1ConcurrentMark::clearRangePrevBitmap(MemRegion mr) { |
1374 | 1887 |
// Note we are overriding the read-only view of the prev map here, via |
1888 |
// the cast. |
|
37122
5318124fe3a8
8151126: Clean up duplicate code for clearing the mark bitmaps
tschatzl
parents:
37073
diff
changeset
|
1889 |
((G1CMBitMap*)_prevMarkBitMap)->clear_range(mr); |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1890 |
} |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1891 |
|
1374 | 1892 |
HeapRegion* |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1893 |
G1ConcurrentMark::claim_region(uint worker_id) { |
1374 | 1894 |
// "checkpoint" the finger |
1895 |
HeapWord* finger = _finger; |
|
1896 |
||
1897 |
// _heap_end will not change underneath our feet; it only changes at |
|
1898 |
// yield points. |
|
1899 |
while (finger < _heap_end) { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
1900 |
assert(_g1h->is_in_g1_reserved(finger), "invariant"); |
1374 | 1901 |
|
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1902 |
HeapRegion* curr_region = _g1h->heap_region_containing(finger); |
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1903 |
|
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1904 |
// Above heap_region_containing may return NULL as we always scan claim |
26160 | 1905 |
// until the end of the heap. In this case, just jump to the next region. |
1906 |
HeapWord* end = curr_region != NULL ? curr_region->end() : finger + HeapRegion::GrainWords; |
|
9994 | 1907 |
|
1908 |
// Is the gap between reading the finger and doing the CAS too long? |
|
1909 |
HeapWord* res = (HeapWord*) Atomic::cmpxchg_ptr(end, &_finger, finger); |
|
26160 | 1910 |
if (res == finger && curr_region != NULL) { |
1374 | 1911 |
// we succeeded |
26160 | 1912 |
HeapWord* bottom = curr_region->bottom(); |
1913 |
HeapWord* limit = curr_region->next_top_at_mark_start(); |
|
1914 |
||
1374 | 1915 |
// notice that _finger == end cannot be guaranteed here since, |
1916 |
// someone else might have moved the finger even further |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
1917 |
assert(_finger >= end, "the finger should have moved forward"); |
1374 | 1918 |
|
1919 |
if (limit > bottom) { |
|
1920 |
return curr_region; |
|
1921 |
} else { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
1922 |
assert(limit == bottom, |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
1923 |
"the region limit should be at bottom"); |
1374 | 1924 |
// we return NULL and the caller should try calling |
1925 |
// claim_region() again. |
|
1926 |
return NULL; |
|
1927 |
} |
|
1928 |
} else { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
1929 |
assert(_finger > finger, "the finger should have moved forward"); |
1374 | 1930 |
// read it again |
1931 |
finger = _finger; |
|
1932 |
} |
|
1933 |
} |
|
1934 |
||
1935 |
return NULL; |
|
1936 |
} |
|
1937 |
||
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1938 |
#ifndef PRODUCT |
31994
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1939 |
class VerifyNoCSetOops VALUE_OBJ_CLASS_SPEC { |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1940 |
private: |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1941 |
G1CollectedHeap* _g1h; |
31994
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1942 |
const char* _phase; |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1943 |
int _info; |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1944 |
|
31994
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1945 |
public: |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1946 |
VerifyNoCSetOops(const char* phase, int info = -1) : |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1947 |
_g1h(G1CollectedHeap::heap()), |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1948 |
_phase(phase), |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1949 |
_info(info) |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1950 |
{ } |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1951 |
|
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1952 |
void operator()(oop obj) const { |
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1953 |
guarantee(obj->is_oop(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1954 |
"Non-oop " PTR_FORMAT ", phase: %s, info: %d", |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1955 |
p2i(obj), _phase, _info); |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1956 |
guarantee(!_g1h->obj_in_cs(obj), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1957 |
"obj: " PTR_FORMAT " in CSet, phase: %s, info: %d", |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1958 |
p2i(obj), _phase, _info); |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1959 |
} |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1960 |
}; |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1961 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1962 |
void G1ConcurrentMark::verify_no_cset_oops() { |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1963 |
assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint"); |
31331
a7c714b6cfb3
7097567: G1: abstract and encapsulate collector phases and transitions between them
drwhite
parents:
31330
diff
changeset
|
1964 |
if (!G1CollectedHeap::heap()->collector_state()->mark_in_progress()) { |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
1965 |
return; |
1374 | 1966 |
} |
6761
f9191297ce83
6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents:
6759
diff
changeset
|
1967 |
|
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1968 |
// Verify entries on the global mark stack |
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
1969 |
_global_mark_stack.iterate(VerifyNoCSetOops("Stack")); |
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1970 |
|
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1971 |
// Verify entries on the task queues |
31994
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1972 |
for (uint i = 0; i < _max_worker_id; ++i) { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1973 |
G1CMTaskQueue* queue = _task_queues->queue(i); |
31994
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1974 |
queue->iterate(VerifyNoCSetOops("Queue", i)); |
6761
f9191297ce83
6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents:
6759
diff
changeset
|
1975 |
} |
f9191297ce83
6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents:
6759
diff
changeset
|
1976 |
|
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1977 |
// Verify the global finger |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1978 |
HeapWord* global_finger = finger(); |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1979 |
if (global_finger != NULL && global_finger < _heap_end) { |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1980 |
// Since we always iterate over all regions, we might get a NULL HeapRegion |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1981 |
// here. |
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1982 |
HeapRegion* global_hr = _g1h->heap_region_containing(global_finger); |
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1983 |
guarantee(global_hr == NULL || global_finger == global_hr->bottom(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1984 |
"global finger: " PTR_FORMAT " region: " HR_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1985 |
p2i(global_finger), HR_FORMAT_PARAMS(global_hr)); |
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1986 |
} |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1987 |
|
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1988 |
// Verify the task fingers |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1989 |
assert(parallel_marking_threads() <= _max_worker_id, "sanity"); |
31994
3721b7aa3a0d
8079082: VerifyNoCSetOopsClosure is derived twice from Closure
kbarrett
parents:
31592
diff
changeset
|
1990 |
for (uint i = 0; i < parallel_marking_threads(); ++i) { |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
1991 |
G1CMTask* task = _tasks[i]; |
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1992 |
HeapWord* task_finger = task->finger(); |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1993 |
if (task_finger != NULL && task_finger < _heap_end) { |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1994 |
// See above note on the global finger verification. |
33786
ac8da6513351
8139867: Change how startsHumongous and continuesHumongous regions work in G1.
david
parents:
33759
diff
changeset
|
1995 |
HeapRegion* task_hr = _g1h->heap_region_containing(task_finger); |
30279
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1996 |
guarantee(task_hr == NULL || task_finger == task_hr->bottom() || |
c3b8486760aa
8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer
kbarrett
parents:
30268
diff
changeset
|
1997 |
!task_hr->in_collection_set(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1998 |
"task finger: " PTR_FORMAT " region: " HR_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
33103
diff
changeset
|
1999 |
p2i(task_finger), HR_FORMAT_PARAMS(task_hr)); |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
2000 |
} |
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
2001 |
} |
1374 | 2002 |
} |
11455
a6ab3d8b9a4c
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
11451
diff
changeset
|
2003 |
#endif // PRODUCT |
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
2004 |
void G1ConcurrentMark::create_live_data() { |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2005 |
_g1h->g1_rem_set()->create_card_live_data(_parallel_workers, _nextMarkBitMap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2006 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2007 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2008 |
void G1ConcurrentMark::finalize_live_data() { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2009 |
_g1h->g1_rem_set()->finalize_card_live_data(_g1h->workers(), _nextMarkBitMap); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2010 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2011 |
|
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2012 |
void G1ConcurrentMark::verify_live_data() { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2013 |
_g1h->g1_rem_set()->verify_card_live_data(_g1h->workers(), _nextMarkBitMap); |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
2014 |
} |
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
2015 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2016 |
void G1ConcurrentMark::clear_live_data(WorkGang* workers) { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2017 |
_g1h->g1_rem_set()->clear_card_live_data(workers); |
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
2018 |
} |
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
2019 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2020 |
#ifdef ASSERT |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2021 |
void G1ConcurrentMark::verify_live_data_clear() { |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2022 |
_g1h->g1_rem_set()->verify_card_live_data_is_clear(); |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
2023 |
} |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2024 |
#endif |
11583
83a7383de44c
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
11577
diff
changeset
|
2025 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2026 |
void G1ConcurrentMark::print_stats() { |
35061 | 2027 |
if (!log_is_enabled(Debug, gc, stats)) { |
2028 |
return; |
|
2029 |
} |
|
2030 |
log_debug(gc, stats)("---------------------------------------------------------------------"); |
|
2031 |
for (size_t i = 0; i < _active_tasks; ++i) { |
|
2032 |
_tasks[i]->print_stats(); |
|
2033 |
log_debug(gc, stats)("---------------------------------------------------------------------"); |
|
1374 | 2034 |
} |
2035 |
} |
|
2036 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2037 |
void G1ConcurrentMark::abort() { |
31397
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31346
diff
changeset
|
2038 |
if (!cmThread()->during_cycle() || _has_aborted) { |
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31346
diff
changeset
|
2039 |
// We haven't started a concurrent cycle or we have already aborted it. No need to do anything. |
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31346
diff
changeset
|
2040 |
return; |
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31346
diff
changeset
|
2041 |
} |
c9cc3289b80c
8129549: G1: Make sure the concurrent thread does not mix its logging with the STW pauses
brutisso
parents:
31346
diff
changeset
|
2042 |
|
25728
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25492
diff
changeset
|
2043 |
// Clear all marks in the next bitmap for the next marking cycle. This will allow us to skip the next |
7f8a76e3baa8
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
25492
diff
changeset
|
2044 |
// concurrent bitmap clearing. |
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2045 |
{ |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2046 |
GCTraceTime(Debug, gc)("Clear Next Bitmap"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2047 |
clear_bitmap(_nextMarkBitMap, _g1h->workers(), false); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2048 |
} |
24244
2c7a1e5649bd
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
24106
diff
changeset
|
2049 |
// Note we cannot clear the previous marking bitmap here |
2c7a1e5649bd
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
24106
diff
changeset
|
2050 |
// since VerifyDuringGC verifies the objects marked during |
2c7a1e5649bd
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
24106
diff
changeset
|
2051 |
// a full GC against the previous bitmap. |
2c7a1e5649bd
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
24106
diff
changeset
|
2052 |
|
37414
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2053 |
{ |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2054 |
GCTraceTime(Debug, gc)("Clear Live Data"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2055 |
clear_live_data(_g1h->workers()); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2056 |
} |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2057 |
DEBUG_ONLY({ |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2058 |
GCTraceTime(Debug, gc)("Verify Live Data Clear"); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2059 |
verify_live_data_clear(); |
2672ba9af0dc
8151386: Extract card live data out of G1ConcurrentMark
tschatzl
parents:
37413
diff
changeset
|
2060 |
}) |
1374 | 2061 |
// Empty mark stack |
15090
18bfcc1bbe39
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
14740
diff
changeset
|
2062 |
reset_marking_state(); |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
2063 |
for (uint i = 0; i < _max_worker_id; ++i) { |
1374 | 2064 |
_tasks[i]->clear_region_fields(); |
6761
f9191297ce83
6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents:
6759
diff
changeset
|
2065 |
} |
24468
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
2066 |
_first_overflow_barrier_sync.abort(); |
cb71997b6484
8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents:
24244
diff
changeset
|
2067 |
_second_overflow_barrier_sync.abort(); |
24848 | 2068 |
_has_aborted = true; |
1374 | 2069 |
|
2070 |
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); |
|
2071 |
satb_mq_set.abandon_partial_marking(); |
|
5082
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
2072 |
// This can be called either during or outside marking, we'll read |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
2073 |
// the expected_active value from the SATB queue set. |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
2074 |
satb_mq_set.set_active_all_threads( |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
2075 |
false, /* new active value */ |
19e725a3d2eb
6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents:
5079
diff
changeset
|
2076 |
satb_mq_set.is_active() /* expected_active */); |
1374 | 2077 |
} |
2078 |
||
2079 |
static void print_ms_time_info(const char* prefix, const char* name, |
|
2080 |
NumberSeq& ns) { |
|
35061 | 2081 |
log_trace(gc, marking)("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).", |
1374 | 2082 |
prefix, ns.num(), name, ns.sum()/1000.0, ns.avg()); |
2083 |
if (ns.num() > 0) { |
|
35061 | 2084 |
log_trace(gc, marking)("%s [std. dev = %8.2f ms, max = %8.2f ms]", |
1374 | 2085 |
prefix, ns.sd(), ns.maximum()); |
2086 |
} |
|
2087 |
} |
|
2088 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2089 |
void G1ConcurrentMark::print_summary_info() { |
37242 | 2090 |
Log(gc, marking) log; |
35061 | 2091 |
if (!log.is_trace()) { |
2092 |
return; |
|
2093 |
} |
|
2094 |
||
2095 |
log.trace(" Concurrent marking:"); |
|
1374 | 2096 |
print_ms_time_info(" ", "init marks", _init_times); |
2097 |
print_ms_time_info(" ", "remarks", _remark_times); |
|
2098 |
{ |
|
2099 |
print_ms_time_info(" ", "final marks", _remark_mark_times); |
|
2100 |
print_ms_time_info(" ", "weak refs", _remark_weak_ref_times); |
|
2101 |
||
2102 |
} |
|
2103 |
print_ms_time_info(" ", "cleanups", _cleanup_times); |
|
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
2104 |
log.trace(" Finalize live data total time = %8.2f s (avg = %8.2f ms).", |
35061 | 2105 |
_total_counting_time, (_cleanup_times.num() > 0 ? _total_counting_time * 1000.0 / (double)_cleanup_times.num() : 0.0)); |
1374 | 2106 |
if (G1ScrubRemSets) { |
35061 | 2107 |
log.trace(" RS scrub total time = %8.2f s (avg = %8.2f ms).", |
2108 |
_total_rs_scrub_time, (_cleanup_times.num() > 0 ? _total_rs_scrub_time * 1000.0 / (double)_cleanup_times.num() : 0.0)); |
|
1374 | 2109 |
} |
35061 | 2110 |
log.trace(" Total stop_world time = %8.2f s.", |
2111 |
(_init_times.sum() + _remark_times.sum() + _cleanup_times.sum())/1000.0); |
|
2112 |
log.trace(" Total concurrent time = %8.2f s (%8.2f s marking).", |
|
2113 |
cmThread()->vtime_accum(), cmThread()->vtime_mark_accum()); |
|
1374 | 2114 |
} |
2115 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2116 |
void G1ConcurrentMark::print_worker_threads_on(outputStream* st) const { |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
2117 |
_parallel_workers->print_worker_threads_on(st); |
4022 | 2118 |
} |
2119 |
||
37474 | 2120 |
void G1ConcurrentMark::threads_do(ThreadClosure* tc) const { |
2121 |
_parallel_workers->threads_do(tc); |
|
2122 |
} |
|
2123 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2124 |
void G1ConcurrentMark::print_on_error(outputStream* st) const { |
16685
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
2125 |
st->print_cr("Marking Bits (Prev, Next): (CMBitMap*) " PTR_FORMAT ", (CMBitMap*) " PTR_FORMAT, |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24244
diff
changeset
|
2126 |
p2i(_prevMarkBitMap), p2i(_nextMarkBitMap)); |
16685
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
2127 |
_prevMarkBitMap->print_on_error(st, " Prev Bits: "); |
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
2128 |
_nextMarkBitMap->print_on_error(st, " Next Bits: "); |
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
2129 |
} |
41c34debcde0
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
16390
diff
changeset
|
2130 |
|
1374 | 2131 |
// Closure for iteration over bitmaps |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2132 |
class G1CMBitMapClosure : public BitMapClosure { |
1374 | 2133 |
private: |
2134 |
// the bitmap that is being iterated over |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2135 |
G1CMBitMap* _nextMarkBitMap; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2136 |
G1ConcurrentMark* _cm; |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2137 |
G1CMTask* _task; |
1374 | 2138 |
|
2139 |
public: |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2140 |
G1CMBitMapClosure(G1CMTask *task, G1ConcurrentMark* cm, G1CMBitMap* nextMarkBitMap) : |
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2141 |
_task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { } |
1374 | 2142 |
|
2143 |
bool do_bit(size_t offset) { |
|
2144 |
HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset); |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2145 |
assert(_nextMarkBitMap->isMarked(addr), "invariant"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2146 |
assert( addr < _cm->finger(), "invariant"); |
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2147 |
assert(addr >= _task->finger(), "invariant"); |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2148 |
|
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2149 |
// We move that task's local finger along. |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2150 |
_task->move_finger_to(addr); |
1374 | 2151 |
|
2152 |
_task->scan_object(oop(addr)); |
|
2153 |
// we only partially drain the local queue and global stack |
|
2154 |
_task->drain_local_queue(true); |
|
2155 |
_task->drain_global_stack(true); |
|
2156 |
||
2157 |
// if the has_aborted flag has been raised, we need to bail out of |
|
2158 |
// the iteration |
|
2159 |
return !_task->has_aborted(); |
|
2160 |
} |
|
2161 |
}; |
|
2162 |
||
33226
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2163 |
static ReferenceProcessor* get_cm_oop_closure_ref_processor(G1CollectedHeap* g1h) { |
36373
231e01457f13
8150421: Delete experimental G1UseConcMarkReferenceProcessing
kbarrett
parents:
36371
diff
changeset
|
2164 |
ReferenceProcessor* result = g1h->ref_processor_cm(); |
231e01457f13
8150421: Delete experimental G1UseConcMarkReferenceProcessing
kbarrett
parents:
36371
diff
changeset
|
2165 |
assert(result != NULL, "CM reference processor should not be NULL"); |
33226
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2166 |
return result; |
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2167 |
} |
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2168 |
|
9994 | 2169 |
G1CMOopClosure::G1CMOopClosure(G1CollectedHeap* g1h, |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2170 |
G1ConcurrentMark* cm, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2171 |
G1CMTask* task) |
33226
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2172 |
: MetadataAwareOopClosure(get_cm_oop_closure_ref_processor(g1h)), |
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2173 |
_g1h(g1h), _cm(cm), _task(task) |
19cb9b844190
8139341: Hide ExtendedOopClosure::_ref_processor
kbarrett
parents:
33214
diff
changeset
|
2174 |
{ } |
1374 | 2175 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2176 |
void G1CMTask::setup_for_region(HeapRegion* hr) { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2177 |
assert(hr != NULL, |
24106
dae9277bdf2a
8040722: G1: Clean up usages of heap_region_containing
brutisso
parents:
24094
diff
changeset
|
2178 |
"claim_region() should have filtered out NULL regions"); |
1374 | 2179 |
_curr_region = hr; |
2180 |
_finger = hr->bottom(); |
|
2181 |
update_region_limit(); |
|
2182 |
} |
|
2183 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2184 |
void G1CMTask::update_region_limit() { |
1374 | 2185 |
HeapRegion* hr = _curr_region; |
2186 |
HeapWord* bottom = hr->bottom(); |
|
2187 |
HeapWord* limit = hr->next_top_at_mark_start(); |
|
2188 |
||
2189 |
if (limit == bottom) { |
|
2190 |
// The region was collected underneath our feet. |
|
2191 |
// We set the finger to bottom to ensure that the bitmap |
|
2192 |
// iteration that will follow this will not do anything. |
|
2193 |
// (this is not a condition that holds when we set the region up, |
|
2194 |
// as the region is not supposed to be empty in the first place) |
|
2195 |
_finger = bottom; |
|
2196 |
} else if (limit >= _region_limit) { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2197 |
assert(limit >= _finger, "peace of mind"); |
1374 | 2198 |
} else { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2199 |
assert(limit < _region_limit, "only way to get here"); |
1374 | 2200 |
// This can happen under some pretty unusual circumstances. An |
2201 |
// evacuation pause empties the region underneath our feet (NTAMS |
|
2202 |
// at bottom). We then do some allocation in the region (NTAMS |
|
2203 |
// stays at bottom), followed by the region being used as a GC |
|
2204 |
// alloc region (NTAMS will move to top() and the objects |
|
2205 |
// originally below it will be grayed). All objects now marked in |
|
2206 |
// the region are explicitly grayed, if below the global finger, |
|
2207 |
// and we do not need in fact to scan anything else. So, we simply |
|
2208 |
// set _finger to be limit to ensure that the bitmap iteration |
|
2209 |
// doesn't do anything. |
|
2210 |
_finger = limit; |
|
2211 |
} |
|
2212 |
||
2213 |
_region_limit = limit; |
|
2214 |
} |
|
2215 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2216 |
void G1CMTask::giveup_current_region() { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2217 |
assert(_curr_region != NULL, "invariant"); |
1374 | 2218 |
clear_region_fields(); |
2219 |
} |
|
2220 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2221 |
void G1CMTask::clear_region_fields() { |
1374 | 2222 |
// Values for these three fields that indicate that we're not |
2223 |
// holding on to a region. |
|
2224 |
_curr_region = NULL; |
|
2225 |
_finger = NULL; |
|
2226 |
_region_limit = NULL; |
|
2227 |
} |
|
2228 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2229 |
void G1CMTask::set_cm_oop_closure(G1CMOopClosure* cm_oop_closure) { |
9994 | 2230 |
if (cm_oop_closure == NULL) { |
2231 |
assert(_cm_oop_closure != NULL, "invariant"); |
|
2232 |
} else { |
|
2233 |
assert(_cm_oop_closure == NULL, "invariant"); |
|
2234 |
} |
|
2235 |
_cm_oop_closure = cm_oop_closure; |
|
2236 |
} |
|
2237 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2238 |
void G1CMTask::reset(G1CMBitMap* nextMarkBitMap) { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2239 |
guarantee(nextMarkBitMap != NULL, "invariant"); |
1374 | 2240 |
_nextMarkBitMap = nextMarkBitMap; |
2241 |
clear_region_fields(); |
|
2242 |
||
2243 |
_calls = 0; |
|
2244 |
_elapsed_time_ms = 0.0; |
|
2245 |
_termination_time_ms = 0.0; |
|
2246 |
_termination_start_time_ms = 0.0; |
|
2247 |
} |
|
2248 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2249 |
bool G1CMTask::should_exit_termination() { |
1374 | 2250 |
regular_clock_call(); |
2251 |
// This is called when we are in the termination protocol. We should |
|
2252 |
// quit if, for some reason, this task wants to abort or the global |
|
2253 |
// stack is not empty (this means that we can get work from it). |
|
2254 |
return !_cm->mark_stack_empty() || has_aborted(); |
|
2255 |
} |
|
2256 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2257 |
void G1CMTask::reached_limit() { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2258 |
assert(_words_scanned >= _words_scanned_limit || |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2259 |
_refs_reached >= _refs_reached_limit , |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2260 |
"shouldn't have been called otherwise"); |
1374 | 2261 |
regular_clock_call(); |
2262 |
} |
|
2263 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2264 |
void G1CMTask::regular_clock_call() { |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2265 |
if (has_aborted()) return; |
1374 | 2266 |
|
2267 |
// First, we need to recalculate the words scanned and refs reached |
|
2268 |
// limits for the next clock call. |
|
2269 |
recalculate_limits(); |
|
2270 |
||
2271 |
// During the regular clock call we do the following |
|
2272 |
||
2273 |
// (1) If an overflow has been flagged, then we abort. |
|
2274 |
if (_cm->has_overflown()) { |
|
2275 |
set_has_aborted(); |
|
2276 |
return; |
|
2277 |
} |
|
2278 |
||
2279 |
// If we are not concurrent (i.e. we're doing remark) we don't need |
|
2280 |
// to check anything else. The other steps are only needed during |
|
2281 |
// the concurrent marking phase. |
|
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2282 |
if (!concurrent()) return; |
1374 | 2283 |
|
2284 |
// (2) If marking has been aborted for Full GC, then we also abort. |
|
2285 |
if (_cm->has_aborted()) { |
|
2286 |
set_has_aborted(); |
|
2287 |
return; |
|
2288 |
} |
|
2289 |
||
2290 |
double curr_time_ms = os::elapsedVTime() * 1000.0; |
|
2291 |
||
2292 |
// (4) We check whether we should yield. If we have to, then we abort. |
|
24094 | 2293 |
if (SuspendibleThreadSet::should_yield()) { |
1374 | 2294 |
// We should yield. To do this we abort the task. The caller is |
2295 |
// responsible for yielding. |
|
2296 |
set_has_aborted(); |
|
2297 |
return; |
|
2298 |
} |
|
2299 |
||
2300 |
// (5) We check whether we've reached our time quota. If we have, |
|
2301 |
// then we abort. |
|
2302 |
double elapsed_time_ms = curr_time_ms - _start_time_ms; |
|
2303 |
if (elapsed_time_ms > _time_target_ms) { |
|
2304 |
set_has_aborted(); |
|
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
2305 |
_has_timed_out = true; |
1374 | 2306 |
return; |
2307 |
} |
|
2308 |
||
2309 |
// (6) Finally, we check whether there are enough completed STAB |
|
2310 |
// buffers available for processing. If there are, we abort. |
|
2311 |
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); |
|
2312 |
if (!_draining_satb_buffers && satb_mq_set.process_completed_buffers()) { |
|
2313 |
// we do need to process SATB buffers, we'll abort and restart |
|
2314 |
// the marking task to do so |
|
2315 |
set_has_aborted(); |
|
2316 |
return; |
|
2317 |
} |
|
2318 |
} |
|
2319 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2320 |
void G1CMTask::recalculate_limits() { |
1374 | 2321 |
_real_words_scanned_limit = _words_scanned + words_scanned_period; |
2322 |
_words_scanned_limit = _real_words_scanned_limit; |
|
2323 |
||
2324 |
_real_refs_reached_limit = _refs_reached + refs_reached_period; |
|
2325 |
_refs_reached_limit = _real_refs_reached_limit; |
|
2326 |
} |
|
2327 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2328 |
void G1CMTask::decrease_limits() { |
1374 | 2329 |
// This is called when we believe that we're going to do an infrequent |
2330 |
// operation which will increase the per byte scanned cost (i.e. move |
|
2331 |
// entries to/from the global stack). It basically tries to decrease the |
|
2332 |
// scanning limit so that the clock is called earlier. |
|
2333 |
||
2334 |
_words_scanned_limit = _real_words_scanned_limit - |
|
2335 |
3 * words_scanned_period / 4; |
|
2336 |
_refs_reached_limit = _real_refs_reached_limit - |
|
2337 |
3 * refs_reached_period / 4; |
|
2338 |
} |
|
2339 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2340 |
void G1CMTask::move_entries_to_global_stack() { |
1374 | 2341 |
// local array where we'll store the entries that will be popped |
2342 |
// from the local queue |
|
2343 |
oop buffer[global_stack_transfer_size]; |
|
2344 |
||
2345 |
int n = 0; |
|
2346 |
oop obj; |
|
2347 |
while (n < global_stack_transfer_size && _task_queue->pop_local(obj)) { |
|
2348 |
buffer[n] = obj; |
|
2349 |
++n; |
|
2350 |
} |
|
2351 |
||
2352 |
if (n > 0) { |
|
2353 |
// we popped at least one entry from the local queue |
|
2354 |
||
2355 |
if (!_cm->mark_stack_push(buffer, n)) { |
|
2356 |
set_has_aborted(); |
|
2357 |
} |
|
2358 |
} |
|
2359 |
||
2360 |
// this operation was quite expensive, so decrease the limits |
|
2361 |
decrease_limits(); |
|
2362 |
} |
|
2363 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2364 |
void G1CMTask::get_entries_from_global_stack() { |
1374 | 2365 |
// local array where we'll store the entries that will be popped |
2366 |
// from the global stack. |
|
2367 |
oop buffer[global_stack_transfer_size]; |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
2368 |
size_t n; |
1374 | 2369 |
_cm->mark_stack_pop(buffer, global_stack_transfer_size, &n); |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2370 |
assert(n <= global_stack_transfer_size, |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2371 |
"we should not pop more than the given limit"); |
1374 | 2372 |
if (n > 0) { |
2373 |
// yes, we did actually pop at least one entry |
|
39966
43c7f35b800e
8160897: Concurrent mark mark stack memory allocation leaks memory
tschatzl
parents:
38637
diff
changeset
|
2374 |
for (size_t i = 0; i < n; ++i) { |
1374 | 2375 |
bool success = _task_queue->push(buffer[i]); |
2376 |
// We only call this when the local queue is empty or under a |
|
2377 |
// given target limit. So, we do not expect this push to fail. |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2378 |
assert(success, "invariant"); |
1374 | 2379 |
} |
2380 |
} |
|
2381 |
||
2382 |
// this operation was quite expensive, so decrease the limits |
|
2383 |
decrease_limits(); |
|
2384 |
} |
|
2385 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2386 |
void G1CMTask::drain_local_queue(bool partially) { |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2387 |
if (has_aborted()) return; |
1374 | 2388 |
|
2389 |
// Decide what the target size is, depending whether we're going to |
|
2390 |
// drain it partially (so that other tasks can steal if they run out |
|
2391 |
// of things to do) or totally (at the very end). |
|
2392 |
size_t target_size; |
|
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2393 |
if (partially) { |
1374 | 2394 |
target_size = MIN2((size_t)_task_queue->max_elems()/3, GCDrainStackTargetSize); |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2395 |
} else { |
1374 | 2396 |
target_size = 0; |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2397 |
} |
1374 | 2398 |
|
2399 |
if (_task_queue->size() > target_size) { |
|
2400 |
oop obj; |
|
2401 |
bool ret = _task_queue->pop_local(obj); |
|
2402 |
while (ret) { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2403 |
assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" ); |
8680 | 2404 |
assert(!_g1h->is_on_master_free_list( |
7923 | 2405 |
_g1h->heap_region_containing((HeapWord*) obj)), "invariant"); |
1374 | 2406 |
|
2407 |
scan_object(obj); |
|
2408 |
||
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2409 |
if (_task_queue->size() <= target_size || has_aborted()) { |
1374 | 2410 |
ret = false; |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2411 |
} else { |
1374 | 2412 |
ret = _task_queue->pop_local(obj); |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2413 |
} |
1374 | 2414 |
} |
2415 |
} |
|
2416 |
} |
|
2417 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2418 |
void G1CMTask::drain_global_stack(bool partially) { |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2419 |
if (has_aborted()) return; |
1374 | 2420 |
|
2421 |
// We have a policy to drain the local queue before we attempt to |
|
2422 |
// drain the global stack. |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2423 |
assert(partially || _task_queue->size() == 0, "invariant"); |
1374 | 2424 |
|
2425 |
// Decide what the target size is, depending whether we're going to |
|
2426 |
// drain it partially (so that other tasks can steal if they run out |
|
2427 |
// of things to do) or totally (at the very end). Notice that, |
|
2428 |
// because we move entries from the global stack in chunks or |
|
2429 |
// because another task might be doing the same, we might in fact |
|
2430 |
// drop below the target. But, this is not a problem. |
|
2431 |
size_t target_size; |
|
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2432 |
if (partially) { |
1374 | 2433 |
target_size = _cm->partial_mark_stack_size_target(); |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2434 |
} else { |
1374 | 2435 |
target_size = 0; |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2436 |
} |
1374 | 2437 |
|
2438 |
if (_cm->mark_stack_size() > target_size) { |
|
2439 |
while (!has_aborted() && _cm->mark_stack_size() > target_size) { |
|
2440 |
get_entries_from_global_stack(); |
|
2441 |
drain_local_queue(partially); |
|
2442 |
} |
|
2443 |
} |
|
2444 |
} |
|
2445 |
||
2446 |
// SATB Queue has several assumptions on whether to call the par or |
|
2447 |
// non-par versions of the methods. this is why some of the code is |
|
2448 |
// replicated. We should really get rid of the single-threaded version |
|
2449 |
// of the code to simplify things. |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2450 |
void G1CMTask::drain_satb_buffers() { |
9999
5f0b78217054
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
9995
diff
changeset
|
2451 |
if (has_aborted()) return; |
1374 | 2452 |
|
2453 |
// We set this so that the regular clock knows that we're in the |
|
2454 |
// middle of draining buffers and doesn't set the abort flag when it |
|
2455 |
// notices that SATB buffers are available for draining. It'd be |
|
2456 |
// very counter productive if it did that. :-) |
|
2457 |
_draining_satb_buffers = true; |
|
2458 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2459 |
G1CMSATBBufferClosure satb_cl(this, _g1h); |
1374 | 2460 |
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set(); |
2461 |
||
2462 |
// This keeps claiming and applying the closure to completed buffers |
|
2463 |
// until we run out of buffers or we need to abort. |
|
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
2464 |
while (!has_aborted() && |
30577
de9fa7ccc1bc
8075215: SATB buffer processing found reclaimed humongous object
kbarrett
parents:
30566
diff
changeset
|
2465 |
satb_mq_set.apply_closure_to_completed_buffer(&satb_cl)) { |
27251
7d667f91ec8d
6979279: remove special-case code for ParallelGCThreads==0
mlarsson
parents:
27247
diff
changeset
|
2466 |
regular_clock_call(); |
1374 | 2467 |
} |
2468 |
||
2469 |
_draining_satb_buffers = false; |
|
2470 |
||
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2471 |
assert(has_aborted() || |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2472 |
concurrent() || |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2473 |
satb_mq_set.completed_buffers_num() == 0, "invariant"); |
1374 | 2474 |
|
2475 |
// again, this was a potentially expensive operation, decrease the |
|
2476 |
// limits to get the regular clock call early |
|
2477 |
decrease_limits(); |
|
2478 |
} |
|
2479 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2480 |
void G1CMTask::print_stats() { |
35061 | 2481 |
log_debug(gc, stats)("Marking Stats, task = %u, calls = %d", |
2482 |
_worker_id, _calls); |
|
2483 |
log_debug(gc, stats)(" Elapsed time = %1.2lfms, Termination time = %1.2lfms", |
|
2484 |
_elapsed_time_ms, _termination_time_ms); |
|
2485 |
log_debug(gc, stats)(" Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms", |
|
2486 |
_step_times_ms.num(), _step_times_ms.avg(), |
|
2487 |
_step_times_ms.sd()); |
|
2488 |
log_debug(gc, stats)(" max = %1.2lfms, total = %1.2lfms", |
|
2489 |
_step_times_ms.maximum(), _step_times_ms.sum()); |
|
1374 | 2490 |
} |
2491 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2492 |
bool G1ConcurrentMark::try_stealing(uint worker_id, int* hash_seed, oop& obj) { |
30566
18eb9aa972d0
8076177: Remove usage of stack.inline.hpp functions from taskqueue.hpp
stefank
parents:
30279
diff
changeset
|
2493 |
return _task_queues->steal(worker_id, hash_seed, obj); |
18eb9aa972d0
8076177: Remove usage of stack.inline.hpp functions from taskqueue.hpp
stefank
parents:
30279
diff
changeset
|
2494 |
} |
18eb9aa972d0
8076177: Remove usage of stack.inline.hpp functions from taskqueue.hpp
stefank
parents:
30279
diff
changeset
|
2495 |
|
1374 | 2496 |
/***************************************************************************** |
2497 |
||
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2498 |
The do_marking_step(time_target_ms, ...) method is the building |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2499 |
block of the parallel marking framework. It can be called in parallel |
1374 | 2500 |
with other invocations of do_marking_step() on different tasks |
2501 |
(but only one per task, obviously) and concurrently with the |
|
2502 |
mutator threads, or during remark, hence it eliminates the need |
|
2503 |
for two versions of the code. When called during remark, it will |
|
2504 |
pick up from where the task left off during the concurrent marking |
|
2505 |
phase. Interestingly, tasks are also claimable during evacuation |
|
2506 |
pauses too, since do_marking_step() ensures that it aborts before |
|
2507 |
it needs to yield. |
|
2508 |
||
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2509 |
The data structures that it uses to do marking work are the |
1374 | 2510 |
following: |
2511 |
||
2512 |
(1) Marking Bitmap. If there are gray objects that appear only |
|
2513 |
on the bitmap (this happens either when dealing with an overflow |
|
2514 |
or when the initial marking phase has simply marked the roots |
|
2515 |
and didn't push them on the stack), then tasks claim heap |
|
2516 |
regions whose bitmap they then scan to find gray objects. A |
|
2517 |
global finger indicates where the end of the last claimed region |
|
2518 |
is. A local finger indicates how far into the region a task has |
|
2519 |
scanned. The two fingers are used to determine how to gray an |
|
2520 |
object (i.e. whether simply marking it is OK, as it will be |
|
2521 |
visited by a task in the future, or whether it needs to be also |
|
2522 |
pushed on a stack). |
|
2523 |
||
2524 |
(2) Local Queue. The local queue of the task which is accessed |
|
2525 |
reasonably efficiently by the task. Other tasks can steal from |
|
2526 |
it when they run out of work. Throughout the marking phase, a |
|
2527 |
task attempts to keep its local queue short but not totally |
|
2528 |
empty, so that entries are available for stealing by other |
|
2529 |
tasks. Only when there is no more work, a task will totally |
|
2530 |
drain its local queue. |
|
2531 |
||
2532 |
(3) Global Mark Stack. This handles local queue overflow. During |
|
2533 |
marking only sets of entries are moved between it and the local |
|
2534 |
queues, as access to it requires a mutex and more fine-grain |
|
2535 |
interaction with it which might cause contention. If it |
|
2536 |
overflows, then the marking phase should restart and iterate |
|
2537 |
over the bitmap to identify gray objects. Throughout the marking |
|
2538 |
phase, tasks attempt to keep the global mark stack at a small |
|
2539 |
length but not totally empty, so that entries are available for |
|
2540 |
popping by other tasks. Only when there is no more work, tasks |
|
2541 |
will totally drain the global mark stack. |
|
2542 |
||
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2543 |
(4) SATB Buffer Queue. This is where completed SATB buffers are |
1374 | 2544 |
made available. Buffers are regularly removed from this queue |
2545 |
and scanned for roots, so that the queue doesn't get too |
|
2546 |
long. During remark, all completed buffers are processed, as |
|
2547 |
well as the filled in parts of any uncompleted buffers. |
|
2548 |
||
2549 |
The do_marking_step() method tries to abort when the time target |
|
2550 |
has been reached. There are a few other cases when the |
|
2551 |
do_marking_step() method also aborts: |
|
2552 |
||
2553 |
(1) When the marking phase has been aborted (after a Full GC). |
|
2554 |
||
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2555 |
(2) When a global overflow (on the global stack) has been |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2556 |
triggered. Before the task aborts, it will actually sync up with |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2557 |
the other tasks to ensure that all the marking data structures |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
2558 |
(local queues, stacks, fingers etc.) are re-initialized so that |
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2559 |
when do_marking_step() completes, the marking phase can |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2560 |
immediately restart. |
1374 | 2561 |
|
2562 |
(3) When enough completed SATB buffers are available. The |
|
2563 |
do_marking_step() method only tries to drain SATB buffers right |
|
2564 |
at the beginning. So, if enough buffers are available, the |
|
2565 |
marking step aborts and the SATB buffers are processed at |
|
2566 |
the beginning of the next invocation. |
|
2567 |
||
2568 |
(4) To yield. when we have to yield then we abort and yield |
|
2569 |
right at the end of do_marking_step(). This saves us from a lot |
|
2570 |
of hassle as, by yielding we might allow a Full GC. If this |
|
2571 |
happens then objects will be compacted underneath our feet, the |
|
2572 |
heap might shrink, etc. We save checking for this by just |
|
2573 |
aborting and doing the yield right at the end. |
|
2574 |
||
2575 |
From the above it follows that the do_marking_step() method should |
|
2576 |
be called in a loop (or, otherwise, regularly) until it completes. |
|
2577 |
||
2578 |
If a marking step completes without its has_aborted() flag being |
|
2579 |
true, it means it has completed the current marking phase (and |
|
2580 |
also all other marking tasks have done so and have all synced up). |
|
2581 |
||
2582 |
A method called regular_clock_call() is invoked "regularly" (in |
|
2583 |
sub ms intervals) throughout marking. It is this clock method that |
|
2584 |
checks all the abort conditions which were mentioned above and |
|
2585 |
decides when the task should abort. A work-based scheme is used to |
|
2586 |
trigger this clock method: when the number of object words the |
|
2587 |
marking phase has scanned or the number of references the marking |
|
2588 |
phase has visited reach a given limit. Additional invocations to |
|
2589 |
the method clock have been planted in a few other strategic places |
|
2590 |
too. The initial reason for the clock method was to avoid calling |
|
2591 |
vtime too regularly, as it is quite expensive. So, once it was in |
|
2592 |
place, it was natural to piggy-back all the other conditions on it |
|
2593 |
too and not constantly check them throughout the code. |
|
2594 |
||
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2595 |
If do_termination is true then do_marking_step will enter its |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2596 |
termination protocol. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2597 |
|
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2598 |
The value of is_serial must be true when do_marking_step is being |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2599 |
called serially (i.e. by the VMThread) and do_marking_step should |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2600 |
skip any synchronization in the termination and overflow code. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2601 |
Examples include the serial remark code and the serial reference |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2602 |
processing closures. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2603 |
|
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2604 |
The value of is_serial must be false when do_marking_step is |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2605 |
being called by any of the worker threads in a work gang. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2606 |
Examples include the concurrent marking code (CMMarkingTask), |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2607 |
the MT remark code, and the MT reference processing closures. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2608 |
|
1374 | 2609 |
*****************************************************************************/ |
2610 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2611 |
void G1CMTask::do_marking_step(double time_target_ms, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2612 |
bool do_termination, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2613 |
bool is_serial) { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2614 |
assert(time_target_ms >= 1.0, "minimum granularity is 1ms"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2615 |
assert(concurrent() == _cm->concurrent(), "they should be the same"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2616 |
|
37985
539c597ee0fa
8154154: Separate G1 specific policy code from the CollectorPolicy class hierarchy
mgerdin
parents:
37474
diff
changeset
|
2617 |
G1Policy* g1_policy = _g1h->g1_policy(); |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2618 |
assert(_task_queues != NULL, "invariant"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2619 |
assert(_task_queue != NULL, "invariant"); |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
2620 |
assert(_task_queues->queue(_worker_id) == _task_queue, "invariant"); |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2621 |
|
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2622 |
assert(!_claimed, |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2623 |
"only one thread should claim this task at any one time"); |
1374 | 2624 |
|
2625 |
// OK, this doesn't safeguard again all possible scenarios, as it is |
|
2626 |
// possible for two threads to set the _claimed flag at the same |
|
2627 |
// time. But it is only for debugging purposes anyway and it will |
|
2628 |
// catch most problems. |
|
2629 |
_claimed = true; |
|
2630 |
||
2631 |
_start_time_ms = os::elapsedVTime() * 1000.0; |
|
2632 |
||
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2633 |
// If do_stealing is true then do_marking_step will attempt to |
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2634 |
// steal work from the other G1CMTasks. It only makes sense to |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2635 |
// enable stealing when the termination protocol is enabled |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2636 |
// and do_marking_step() is not being called serially. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2637 |
bool do_stealing = do_termination && !is_serial; |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2638 |
|
33214
5a00fba36171
8137082: Factor out G1 prediction code from G1CollectorPolicy and clean up
tschatzl
parents:
33122
diff
changeset
|
2639 |
double diff_prediction_ms = _g1h->g1_policy()->predictor().get_new_prediction(&_marking_step_diffs_ms); |
1374 | 2640 |
_time_target_ms = time_target_ms - diff_prediction_ms; |
2641 |
||
2642 |
// set up the variables that are used in the work-based scheme to |
|
2643 |
// call the regular clock method |
|
2644 |
_words_scanned = 0; |
|
2645 |
_refs_reached = 0; |
|
2646 |
recalculate_limits(); |
|
2647 |
||
2648 |
// clear all flags |
|
2649 |
clear_has_aborted(); |
|
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
2650 |
_has_timed_out = false; |
1374 | 2651 |
_draining_satb_buffers = false; |
2652 |
||
2653 |
++_calls; |
|
2654 |
||
2655 |
// Set up the bitmap and oop closures. Anything that uses them is |
|
2656 |
// eventually called from this method, so it is OK to allocate these |
|
2657 |
// statically. |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2658 |
G1CMBitMapClosure bitmap_closure(this, _cm, _nextMarkBitMap); |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2659 |
G1CMOopClosure cm_oop_closure(_g1h, _cm, this); |
9994 | 2660 |
set_cm_oop_closure(&cm_oop_closure); |
1374 | 2661 |
|
2662 |
if (_cm->has_overflown()) { |
|
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2663 |
// This can happen if the mark stack overflows during a GC pause |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2664 |
// and this task, after a yield point, restarts. We have to abort |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2665 |
// as we need to get into the overflow protocol which happens |
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2666 |
// right at the end of this task. |
1374 | 2667 |
set_has_aborted(); |
2668 |
} |
|
2669 |
||
2670 |
// First drain any available SATB buffers. After this, we will not |
|
2671 |
// look at SATB buffers before the next invocation of this method. |
|
2672 |
// If enough completed SATB buffers are queued up, the regular clock |
|
2673 |
// will abort this task so that it restarts. |
|
2674 |
drain_satb_buffers(); |
|
2675 |
// ...then partially drain the local queue and the global stack |
|
2676 |
drain_local_queue(true); |
|
2677 |
drain_global_stack(true); |
|
2678 |
||
2679 |
do { |
|
2680 |
if (!has_aborted() && _curr_region != NULL) { |
|
2681 |
// This means that we're already holding on to a region. |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2682 |
assert(_finger != NULL, "if region is not NULL, then the finger " |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2683 |
"should not be NULL either"); |
1374 | 2684 |
|
2685 |
// We might have restarted this task after an evacuation pause |
|
2686 |
// which might have evacuated the region we're holding on to |
|
2687 |
// underneath our feet. Let's read its limit again to make sure |
|
2688 |
// that we do not iterate over a region of the heap that |
|
2689 |
// contains garbage (update_region_limit() will also move |
|
2690 |
// _finger to the start of the region if it is found empty). |
|
2691 |
update_region_limit(); |
|
2692 |
// We will start from _finger not from the start of the region, |
|
2693 |
// as we might be restarting this task after aborting half-way |
|
2694 |
// through scanning this region. In this case, _finger points to |
|
2695 |
// the address where we last found a marked object. If this is a |
|
2696 |
// fresh region, _finger points to start(). |
|
2697 |
MemRegion mr = MemRegion(_finger, _region_limit); |
|
2698 |
||
26846
7d4376f8560e
8058495: G1: normalize names for isHumongous() and friends
tonyp
parents:
26841
diff
changeset
|
2699 |
assert(!_curr_region->is_humongous() || mr.start() == _curr_region->bottom(), |
15609
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2700 |
"humongous regions should go around loop once only"); |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2701 |
|
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2702 |
// Some special cases: |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2703 |
// If the memory region is empty, we can just give up the region. |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2704 |
// If the current region is humongous then we only need to check |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2705 |
// the bitmap for the bit associated with the start of the object, |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2706 |
// scan the object if it's live, and give up the region. |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2707 |
// Otherwise, let's iterate over the bitmap of the part of the region |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2708 |
// that is left. |
15604
0209977cd9c4
7052429: G1: Avoid unnecessary scanning of humongous regions during concurrent marking
johnc
parents:
15495
diff
changeset
|
2709 |
// If the iteration is successful, give up the region. |
15609
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2710 |
if (mr.is_empty()) { |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2711 |
giveup_current_region(); |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2712 |
regular_clock_call(); |
26846
7d4376f8560e
8058495: G1: normalize names for isHumongous() and friends
tonyp
parents:
26841
diff
changeset
|
2713 |
} else if (_curr_region->is_humongous() && mr.start() == _curr_region->bottom()) { |
15609
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2714 |
if (_nextMarkBitMap->isMarked(mr.start())) { |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2715 |
// The object is marked - apply the closure |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2716 |
BitMap::idx_t offset = _nextMarkBitMap->heapWordToOffset(mr.start()); |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2717 |
bitmap_closure.do_bit(offset); |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2718 |
} |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2719 |
// Even if this task aborted while scanning the humongous object |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2720 |
// we can (and should) give up the current region. |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2721 |
giveup_current_region(); |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2722 |
regular_clock_call(); |
f2f53c966990
8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents:
15604
diff
changeset
|
2723 |
} else if (_nextMarkBitMap->iterate(&bitmap_closure, mr)) { |
1374 | 2724 |
giveup_current_region(); |
2725 |
regular_clock_call(); |
|
2726 |
} else { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2727 |
assert(has_aborted(), "currently the only way to do so"); |
1374 | 2728 |
// The only way to abort the bitmap iteration is to return |
2729 |
// false from the do_bit() method. However, inside the |
|
2730 |
// do_bit() method we move the _finger to point to the |
|
2731 |
// object currently being looked at. So, if we bail out, we |
|
2732 |
// have definitely set _finger to something non-null. |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2733 |
assert(_finger != NULL, "invariant"); |
1374 | 2734 |
|
2735 |
// Region iteration was actually aborted. So now _finger |
|
2736 |
// points to the address of the object we last scanned. If we |
|
2737 |
// leave it there, when we restart this task, we will rescan |
|
2738 |
// the object. It is easy to avoid this. We move the finger by |
|
2739 |
// enough to point to the next possible object header (the |
|
2740 |
// bitmap knows by how much we need to move it as it knows its |
|
2741 |
// granularity). |
|
5079
c8e827e5dc2b
6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents:
5035
diff
changeset
|
2742 |
assert(_finger < _region_limit, "invariant"); |
15949
a55dea304e8c
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
15609
diff
changeset
|
2743 |
HeapWord* new_finger = _nextMarkBitMap->nextObject(_finger); |
5079
c8e827e5dc2b
6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents:
5035
diff
changeset
|
2744 |
// Check if bitmap iteration was aborted while scanning the last object |
c8e827e5dc2b
6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents:
5035
diff
changeset
|
2745 |
if (new_finger >= _region_limit) { |
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2746 |
giveup_current_region(); |
5079
c8e827e5dc2b
6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents:
5035
diff
changeset
|
2747 |
} else { |
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2748 |
move_finger_to(new_finger); |
5079
c8e827e5dc2b
6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents:
5035
diff
changeset
|
2749 |
} |
1374 | 2750 |
} |
2751 |
} |
|
2752 |
// At this point we have either completed iterating over the |
|
2753 |
// region we were holding on to, or we have aborted. |
|
2754 |
||
2755 |
// We then partially drain the local queue and the global stack. |
|
2756 |
// (Do we really need this?) |
|
2757 |
drain_local_queue(true); |
|
2758 |
drain_global_stack(true); |
|
2759 |
||
2760 |
// Read the note on the claim_region() method on why it might |
|
2761 |
// return NULL with potentially more regions available for |
|
2762 |
// claiming and why we have to check out_of_regions() to determine |
|
2763 |
// whether we're done or not. |
|
2764 |
while (!has_aborted() && _curr_region == NULL && !_cm->out_of_regions()) { |
|
2765 |
// We are going to try to claim a new region. We should have |
|
2766 |
// given up on the previous one. |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2767 |
// Separated the asserts so that we know which one fires. |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2768 |
assert(_curr_region == NULL, "invariant"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2769 |
assert(_finger == NULL, "invariant"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2770 |
assert(_region_limit == NULL, "invariant"); |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
2771 |
HeapRegion* claimed_region = _cm->claim_region(_worker_id); |
1374 | 2772 |
if (claimed_region != NULL) { |
2773 |
// Yes, we managed to claim one |
|
2774 |
setup_for_region(claimed_region); |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2775 |
assert(_curr_region == claimed_region, "invariant"); |
1374 | 2776 |
} |
2777 |
// It is important to call the regular clock here. It might take |
|
2778 |
// a while to claim a region if, for example, we hit a large |
|
2779 |
// block of empty regions. So we need to call the regular clock |
|
2780 |
// method once round the loop to make sure it's called |
|
2781 |
// frequently enough. |
|
2782 |
regular_clock_call(); |
|
2783 |
} |
|
2784 |
||
2785 |
if (!has_aborted() && _curr_region == NULL) { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2786 |
assert(_cm->out_of_regions(), |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2787 |
"at this point we should be out of regions"); |
1374 | 2788 |
} |
2789 |
} while ( _curr_region != NULL && !has_aborted()); |
|
2790 |
||
2791 |
if (!has_aborted()) { |
|
2792 |
// We cannot check whether the global stack is empty, since other |
|
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2793 |
// tasks might be pushing objects to it concurrently. |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2794 |
assert(_cm->out_of_regions(), |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2795 |
"at this point we should be out of regions"); |
1374 | 2796 |
// Try to reduce the number of available SATB buffers so that |
2797 |
// remark has less work to do. |
|
2798 |
drain_satb_buffers(); |
|
2799 |
} |
|
2800 |
||
2801 |
// Since we've done everything else, we can now totally drain the |
|
2802 |
// local queue and global stack. |
|
2803 |
drain_local_queue(false); |
|
2804 |
drain_global_stack(false); |
|
2805 |
||
2806 |
// Attempt at work stealing from other task's queues. |
|
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
2807 |
if (do_stealing && !has_aborted()) { |
1374 | 2808 |
// We have not aborted. This means that we have finished all that |
2809 |
// we could. Let's try to do some stealing... |
|
2810 |
||
2811 |
// We cannot check whether the global stack is empty, since other |
|
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2812 |
// tasks might be pushing objects to it concurrently. |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2813 |
assert(_cm->out_of_regions() && _task_queue->size() == 0, |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2814 |
"only way to reach here"); |
1374 | 2815 |
while (!has_aborted()) { |
2816 |
oop obj; |
|
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
2817 |
if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2818 |
assert(_nextMarkBitMap->isMarked((HeapWord*) obj), |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2819 |
"any stolen object should be marked"); |
1374 | 2820 |
scan_object(obj); |
2821 |
||
2822 |
// And since we're towards the end, let's totally drain the |
|
2823 |
// local queue and global stack. |
|
2824 |
drain_local_queue(false); |
|
2825 |
drain_global_stack(false); |
|
2826 |
} else { |
|
2827 |
break; |
|
2828 |
} |
|
2829 |
} |
|
2830 |
} |
|
2831 |
||
2832 |
// We still haven't aborted. Now, let's try to get into the |
|
2833 |
// termination protocol. |
|
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
2834 |
if (do_termination && !has_aborted()) { |
1374 | 2835 |
// We cannot check whether the global stack is empty, since other |
12272
f87fd1292095
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
11584
diff
changeset
|
2836 |
// tasks might be concurrently pushing objects on it. |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2837 |
// Separated the asserts so that we know which one fires. |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2838 |
assert(_cm->out_of_regions(), "only way to reach here"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2839 |
assert(_task_queue->size() == 0, "only way to reach here"); |
1374 | 2840 |
_termination_start_time_ms = os::elapsedVTime() * 1000.0; |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2841 |
|
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2842 |
// The G1CMTask class also extends the TerminatorTerminator class, |
1374 | 2843 |
// hence its should_exit_termination() method will also decide |
2844 |
// whether to exit the termination protocol or not. |
|
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2845 |
bool finished = (is_serial || |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2846 |
_cm->terminator()->offer_termination(this)); |
1374 | 2847 |
double termination_end_time_ms = os::elapsedVTime() * 1000.0; |
2848 |
_termination_time_ms += |
|
2849 |
termination_end_time_ms - _termination_start_time_ms; |
|
2850 |
||
2851 |
if (finished) { |
|
2852 |
// We're all done. |
|
2853 |
||
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
2854 |
if (_worker_id == 0) { |
1374 | 2855 |
// let's allow task 0 to do this |
2856 |
if (concurrent()) { |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2857 |
assert(_cm->concurrent_marking_in_progress(), "invariant"); |
1374 | 2858 |
// we need to set this to false before the next |
2859 |
// safepoint. This way we ensure that the marking phase |
|
2860 |
// doesn't observe any more heap expansions. |
|
2861 |
_cm->clear_concurrent_marking_in_progress(); |
|
2862 |
} |
|
2863 |
} |
|
2864 |
||
2865 |
// We can now guarantee that the global stack is empty, since |
|
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2866 |
// all other tasks have finished. We separated the guarantees so |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2867 |
// that, if a condition is false, we can immediately find out |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2868 |
// which one. |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2869 |
guarantee(_cm->out_of_regions(), "only way to reach here"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2870 |
guarantee(_cm->mark_stack_empty(), "only way to reach here"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2871 |
guarantee(_task_queue->size() == 0, "only way to reach here"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2872 |
guarantee(!_cm->has_overflown(), "only way to reach here"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2873 |
guarantee(!_cm->mark_stack_overflow(), "only way to reach here"); |
1374 | 2874 |
} else { |
2875 |
// Apparently there's more work to do. Let's abort this task. It |
|
2876 |
// will restart it and we can hopefully find more things to do. |
|
2877 |
set_has_aborted(); |
|
2878 |
} |
|
2879 |
} |
|
2880 |
||
2881 |
// Mainly for debugging purposes to make sure that a pointer to the |
|
2882 |
// closure which was statically allocated in this frame doesn't |
|
2883 |
// escape it by accident. |
|
9994 | 2884 |
set_cm_oop_closure(NULL); |
1374 | 2885 |
double end_time_ms = os::elapsedVTime() * 1000.0; |
2886 |
double elapsed_time_ms = end_time_ms - _start_time_ms; |
|
2887 |
// Update the step history. |
|
2888 |
_step_times_ms.add(elapsed_time_ms); |
|
2889 |
||
2890 |
if (has_aborted()) { |
|
2891 |
// The task was aborted for some reason. |
|
8073
a14dc27842dc
6608385: G1: need to support parallel reference processing
johnc
parents:
7923
diff
changeset
|
2892 |
if (_has_timed_out) { |
1374 | 2893 |
double diff_ms = elapsed_time_ms - _time_target_ms; |
2894 |
// Keep statistics of how well we did with respect to hitting |
|
2895 |
// our target only if we actually timed out (if we aborted for |
|
2896 |
// other reasons, then the results might get skewed). |
|
2897 |
_marking_step_diffs_ms.add(diff_ms); |
|
2898 |
} |
|
2899 |
||
2900 |
if (_cm->has_overflown()) { |
|
2901 |
// This is the interesting one. We aborted because a global |
|
2902 |
// overflow was raised. This means we have to restart the |
|
2903 |
// marking phase and start iterating over regions. However, in |
|
2904 |
// order to do this we have to make sure that all tasks stop |
|
22551 | 2905 |
// what they are doing and re-initialize in a safe manner. We |
1374 | 2906 |
// will achieve this with the use of two barrier sync points. |
2907 |
||
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2908 |
if (!is_serial) { |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2909 |
// We only need to enter the sync barrier if being called |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2910 |
// from a parallel context |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2911 |
_cm->enter_first_sync_barrier(_worker_id); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2912 |
|
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2913 |
// When we exit this sync barrier we know that all tasks have |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2914 |
// stopped doing marking work. So, it's now safe to |
22551 | 2915 |
// re-initialize our data structures. At the end of this method, |
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2916 |
// task 0 will clear the global data structures. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2917 |
} |
1374 | 2918 |
|
2919 |
// We clear the local state of this task... |
|
2920 |
clear_region_fields(); |
|
2921 |
||
16388
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2922 |
if (!is_serial) { |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2923 |
// ...and enter the second barrier. |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2924 |
_cm->enter_second_sync_barrier(_worker_id); |
60de0264afe8
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
15960
diff
changeset
|
2925 |
} |
16389
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
2926 |
// At this point, if we're during the concurrent phase of |
70f98431dd29
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
16388
diff
changeset
|
2927 |
// marking, everything has been re-initialized and we're |
1374 | 2928 |
// ready to restart. |
2929 |
} |
|
2930 |
} |
|
2931 |
||
2932 |
_claimed = false; |
|
2933 |
} |
|
2934 |
||
35943
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2935 |
G1CMTask::G1CMTask(uint worker_id, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2936 |
G1ConcurrentMark* cm, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2937 |
G1CMTaskQueue* task_queue, |
e726308008c0
8148973: Rename g1/concurrentMark.{hpp,cpp,inline.hpp} to g1/g1ConcurrentMark.{hpp,cpp,inline.hpp}
ehelin
parents:
35902
diff
changeset
|
2938 |
G1CMTaskQueueSet* task_queues) |
1374 | 2939 |
: _g1h(G1CollectedHeap::heap()), |
14073
6012178c0c19
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
13919
diff
changeset
|
2940 |
_worker_id(worker_id), _cm(cm), |
1374 | 2941 |
_claimed(false), |
2942 |
_nextMarkBitMap(NULL), _hash_seed(17), |
|
2943 |
_task_queue(task_queue), |
|
2944 |
_task_queues(task_queues), |
|
37413
2f71679d06dd
8077144: Concurrent mark initialization takes too long
tschatzl
parents:
37242
diff
changeset
|
2945 |
_cm_oop_closure(NULL) { |
4026
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2946 |
guarantee(task_queue != NULL, "invariant"); |
10386ea70fe5
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
4025
diff
changeset
|
2947 |
guarantee(task_queues != NULL, "invariant"); |
1374 | 2948 |
|
2949 |
_marking_step_diffs_ms.add(0.5); |
|
2950 |
} |
|
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2951 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2952 |
// These are formatting macros that are used below to ensure |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2953 |
// consistent formatting. The *_H_* versions are used to format the |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2954 |
// header for a particular value and they should be kept consistent |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2955 |
// with the corresponding macro. Also note that most of the macros add |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2956 |
// the necessary white space (as a prefix) which makes them a bit |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2957 |
// easier to compose. |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2958 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2959 |
// All the output lines are prefixed with this string to be able to |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2960 |
// identify them easily in a large log file. |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2961 |
#define G1PPRL_LINE_PREFIX "###" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2962 |
|
31592
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31397
diff
changeset
|
2963 |
#define G1PPRL_ADDR_BASE_FORMAT " " PTR_FORMAT "-" PTR_FORMAT |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2964 |
#ifdef _LP64 |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2965 |
#define G1PPRL_ADDR_BASE_H_FORMAT " %37s" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2966 |
#else // _LP64 |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2967 |
#define G1PPRL_ADDR_BASE_H_FORMAT " %21s" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2968 |
#endif // _LP64 |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2969 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2970 |
// For per-region info |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2971 |
#define G1PPRL_TYPE_FORMAT " %-4s" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2972 |
#define G1PPRL_TYPE_H_FORMAT " %4s" |
31592
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31397
diff
changeset
|
2973 |
#define G1PPRL_BYTE_FORMAT " " SIZE_FORMAT_W(9) |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2974 |
#define G1PPRL_BYTE_H_FORMAT " %9s" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2975 |
#define G1PPRL_DOUBLE_FORMAT " %14.1f" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2976 |
#define G1PPRL_DOUBLE_H_FORMAT " %14s" |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2977 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2978 |
// For summary info |
31592
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31397
diff
changeset
|
2979 |
#define G1PPRL_SUM_ADDR_FORMAT(tag) " " tag ":" G1PPRL_ADDR_BASE_FORMAT |
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31397
diff
changeset
|
2980 |
#define G1PPRL_SUM_BYTE_FORMAT(tag) " " tag ": " SIZE_FORMAT |
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31397
diff
changeset
|
2981 |
#define G1PPRL_SUM_MB_FORMAT(tag) " " tag ": %1.2f MB" |
43f48e165466
8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"
bpittore
parents:
31397
diff
changeset
|
2982 |
#define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag) " / %1.2f %%" |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2983 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2984 |
G1PrintRegionLivenessInfoClosure:: |
35061 | 2985 |
G1PrintRegionLivenessInfoClosure(const char* phase_name) |
2986 |
: _total_used_bytes(0), _total_capacity_bytes(0), |
|
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2987 |
_total_prev_live_bytes(0), _total_next_live_bytes(0), |
19339 | 2988 |
_total_remset_bytes(0), _total_strong_code_roots_bytes(0) { |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2989 |
G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2990 |
MemRegion g1_reserved = g1h->g1_reserved(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2991 |
double now = os::elapsedTime(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2992 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
2993 |
// Print the header of the output. |
35061 | 2994 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX" PHASE %s @ %1.3f", phase_name, now); |
2995 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX" HEAP" |
|
2996 |
G1PPRL_SUM_ADDR_FORMAT("reserved") |
|
2997 |
G1PPRL_SUM_BYTE_FORMAT("region-size"), |
|
2998 |
p2i(g1_reserved.start()), p2i(g1_reserved.end()), |
|
2999 |
HeapRegion::GrainBytes); |
|
3000 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX); |
|
3001 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX |
|
3002 |
G1PPRL_TYPE_H_FORMAT |
|
3003 |
G1PPRL_ADDR_BASE_H_FORMAT |
|
3004 |
G1PPRL_BYTE_H_FORMAT |
|
3005 |
G1PPRL_BYTE_H_FORMAT |
|
3006 |
G1PPRL_BYTE_H_FORMAT |
|
3007 |
G1PPRL_DOUBLE_H_FORMAT |
|
3008 |
G1PPRL_BYTE_H_FORMAT |
|
3009 |
G1PPRL_BYTE_H_FORMAT, |
|
3010 |
"type", "address-range", |
|
3011 |
"used", "prev-live", "next-live", "gc-eff", |
|
3012 |
"remset", "code-roots"); |
|
3013 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX |
|
3014 |
G1PPRL_TYPE_H_FORMAT |
|
3015 |
G1PPRL_ADDR_BASE_H_FORMAT |
|
3016 |
G1PPRL_BYTE_H_FORMAT |
|
3017 |
G1PPRL_BYTE_H_FORMAT |
|
3018 |
G1PPRL_BYTE_H_FORMAT |
|
3019 |
G1PPRL_DOUBLE_H_FORMAT |
|
3020 |
G1PPRL_BYTE_H_FORMAT |
|
3021 |
G1PPRL_BYTE_H_FORMAT, |
|
3022 |
"", "", |
|
3023 |
"(bytes)", "(bytes)", "(bytes)", "(bytes/ms)", |
|
3024 |
"(bytes)", "(bytes)"); |
|
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3025 |
} |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3026 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3027 |
bool G1PrintRegionLivenessInfoClosure::doHeapRegion(HeapRegion* r) { |
26696
623a25e6c686
8057768: Make heap region region type in G1 HeapRegion explicit
tonyp
parents:
26326
diff
changeset
|
3028 |
const char* type = r->get_type_str(); |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3029 |
HeapWord* bottom = r->bottom(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3030 |
HeapWord* end = r->end(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3031 |
size_t capacity_bytes = r->capacity(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3032 |
size_t used_bytes = r->used(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3033 |
size_t prev_live_bytes = r->live_bytes(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3034 |
size_t next_live_bytes = r->next_live_bytes(); |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3035 |
double gc_eff = r->gc_efficiency(); |
17395
2cd3ef1be718
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
17112
diff
changeset
|
3036 |
size_t remset_bytes = r->rem_set()->mem_size(); |
19339 | 3037 |
size_t strong_code_roots_bytes = r->rem_set()->strong_code_roots_mem_size(); |
3038 |
||
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3039 |
_total_used_bytes += used_bytes; |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3040 |
_total_capacity_bytes += capacity_bytes; |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3041 |
_total_prev_live_bytes += prev_live_bytes; |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3042 |
_total_next_live_bytes += next_live_bytes; |
17395
2cd3ef1be718
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
17112
diff
changeset
|
3043 |
_total_remset_bytes += remset_bytes; |
19339 | 3044 |
_total_strong_code_roots_bytes += strong_code_roots_bytes; |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3045 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3046 |
// Print a line for this particular region. |
35061 | 3047 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX |
3048 |
G1PPRL_TYPE_FORMAT |
|
3049 |
G1PPRL_ADDR_BASE_FORMAT |
|
3050 |
G1PPRL_BYTE_FORMAT |
|
3051 |
G1PPRL_BYTE_FORMAT |
|
3052 |
G1PPRL_BYTE_FORMAT |
|
3053 |
G1PPRL_DOUBLE_FORMAT |
|
3054 |
G1PPRL_BYTE_FORMAT |
|
3055 |
G1PPRL_BYTE_FORMAT, |
|
3056 |
type, p2i(bottom), p2i(end), |
|
3057 |
used_bytes, prev_live_bytes, next_live_bytes, gc_eff, |
|
3058 |
remset_bytes, strong_code_roots_bytes); |
|
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3059 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3060 |
return false; |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3061 |
} |
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3062 |
|
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3063 |
G1PrintRegionLivenessInfoClosure::~G1PrintRegionLivenessInfoClosure() { |
17395
2cd3ef1be718
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
17112
diff
changeset
|
3064 |
// add static memory usages to remembered set sizes |
2cd3ef1be718
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
17112
diff
changeset
|
3065 |
_total_remset_bytes += HeapRegionRemSet::fl_mem_size() + HeapRegionRemSet::static_mem_size(); |
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3066 |
// Print the footer of the output. |
35061 | 3067 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX); |
3068 |
log_trace(gc, liveness)(G1PPRL_LINE_PREFIX |
|
3069 |
" SUMMARY" |
|
3070 |
G1PPRL_SUM_MB_FORMAT("capacity") |
|
3071 |
G1PPRL_SUM_MB_PERC_FORMAT("used") |
|
3072 |
G1PPRL_SUM_MB_PERC_FORMAT("prev-live") |
|
3073 |
G1PPRL_SUM_MB_PERC_FORMAT("next-live") |
|
3074 |
G1PPRL_SUM_MB_FORMAT("remset") |
|
3075 |
G1PPRL_SUM_MB_FORMAT("code-roots"), |
|
3076 |
bytes_to_mb(_total_capacity_bytes), |
|
3077 |
bytes_to_mb(_total_used_bytes), |
|
3078 |
perc(_total_used_bytes, _total_capacity_bytes), |
|
3079 |
bytes_to_mb(_total_prev_live_bytes), |
|
3080 |
perc(_total_prev_live_bytes, _total_capacity_bytes), |
|
3081 |
bytes_to_mb(_total_next_live_bytes), |
|
3082 |
perc(_total_next_live_bytes, _total_capacity_bytes), |
|
3083 |
bytes_to_mb(_total_remset_bytes), |
|
3084 |
bytes_to_mb(_total_strong_code_roots_bytes)); |
|
8930
52368505ee8e
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
8688
diff
changeset
|
3085 |
} |