Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/concurrentMark.hpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 9337d0e7ea4f |
| children | 7848fc12602b |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
7450
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1394
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP | |
| 27 | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
28 #include "classfile/javaClasses.hpp" |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
12080
diff
changeset
|
29 #include "gc_implementation/g1/heapRegionSet.hpp" |
| 20337 | 30 #include "gc_implementation/g1/g1RegionToSpaceMapper.hpp" |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17950
diff
changeset
|
31 #include "gc_implementation/shared/gcId.hpp" |
| 1972 | 32 #include "utilities/taskqueue.hpp" |
| 33 | |
| 342 | 34 class G1CollectedHeap; |
| 20337 | 35 class CMBitMap; |
| 342 | 36 class CMTask; |
| 6197 | 37 typedef GenericTaskQueue<oop, mtGC> CMTaskQueue; |
| 38 typedef GenericTaskQueueSet<CMTaskQueue, mtGC> CMTaskQueueSet; | |
| 342 | 39 |
|
2037
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
40 // Closure used by CM during concurrent reference discovery |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
41 // and reference processing (during remarking) to determine |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
42 // if a particular object is alive. It is primarily used |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
43 // to determine if referents of discovered reference objects |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
44 // are alive. An instance is also embedded into the |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
45 // reference processor as the _is_alive_non_header field |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
46 class G1CMIsAliveClosure: public BoolObjectClosure { |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
47 G1CollectedHeap* _g1; |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
48 public: |
|
5988
2a0172480595
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
4837
diff
changeset
|
49 G1CMIsAliveClosure(G1CollectedHeap* g1) : _g1(g1) { } |
|
2037
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
50 |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
51 bool do_object_b(oop obj); |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
52 }; |
|
b03260081e9b
7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents:
1972
diff
changeset
|
53 |
| 342 | 54 // A generic CM bit map. This is essentially a wrapper around the BitMap |
| 55 // class, with one bit per (1<<_shifter) HeapWords. | |
| 56 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
57 class CMBitMapRO VALUE_OBJ_CLASS_SPEC { |
| 342 | 58 protected: |
| 59 HeapWord* _bmStartWord; // base address of range covered by map | |
| 60 size_t _bmWordSize; // map size (in #HeapWords covered) | |
| 61 const int _shifter; // map to char or bit | |
| 62 BitMap _bm; // the bit map itself | |
| 63 | |
| 64 public: | |
| 65 // constructor | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
66 CMBitMapRO(int shifter); |
| 342 | 67 |
| 68 enum { do_yield = true }; | |
| 69 | |
| 70 // inquiries | |
| 71 HeapWord* startWord() const { return _bmStartWord; } | |
| 72 size_t sizeInWords() const { return _bmWordSize; } | |
| 73 // the following is one past the last word in space | |
| 74 HeapWord* endWord() const { return _bmStartWord + _bmWordSize; } | |
| 75 | |
| 76 // read marks | |
| 77 | |
| 78 bool isMarked(HeapWord* addr) const { | |
| 79 assert(_bmStartWord <= addr && addr < (_bmStartWord + _bmWordSize), | |
| 80 "outside underlying space?"); | |
| 81 return _bm.at(heapWordToOffset(addr)); | |
| 82 } | |
| 83 | |
| 84 // iteration | |
|
4827
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
85 inline bool iterate(BitMapClosure* cl, MemRegion mr); |
|
2e966d967c5c
7121547: G1: High number mispredicted branches while iterating over the marking bitmap
johnc
parents:
4787
diff
changeset
|
86 inline bool iterate(BitMapClosure* cl); |
| 342 | 87 |
| 88 // Return the address corresponding to the next marked bit at or after | |
| 89 // "addr", and before "limit", if "limit" is non-NULL. If there is no | |
| 90 // such bit, returns "limit" if that is non-NULL, or else "endWord()". | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
91 HeapWord* getNextMarkedWordAddress(const HeapWord* addr, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
92 const HeapWord* limit = NULL) const; |
| 342 | 93 // Return the address corresponding to the next unmarked bit at or after |
| 94 // "addr", and before "limit", if "limit" is non-NULL. If there is no | |
| 95 // such bit, returns "limit" if that is non-NULL, or else "endWord()". | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
96 HeapWord* getNextUnmarkedWordAddress(const HeapWord* addr, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
97 const HeapWord* limit = NULL) const; |
| 342 | 98 |
| 99 // conversion utilities | |
| 100 HeapWord* offsetToHeapWord(size_t offset) const { | |
| 101 return _bmStartWord + (offset << _shifter); | |
| 102 } | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
103 size_t heapWordToOffset(const HeapWord* addr) const { |
| 342 | 104 return pointer_delta(addr, _bmStartWord) >> _shifter; |
| 105 } | |
| 106 int heapWordDiffToOffsetDiff(size_t diff) const; | |
|
8733
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
107 |
|
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
108 // The argument addr should be the start address of a valid object |
|
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
109 HeapWord* nextObject(HeapWord* addr) { |
|
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
110 oop obj = (oop) addr; |
|
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
111 HeapWord* res = addr + obj->size(); |
|
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
112 assert(offsetToHeapWord(heapWordToOffset(res)) == res, "sanity"); |
|
9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents:
8014
diff
changeset
|
113 return res; |
| 342 | 114 } |
| 115 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8788
diff
changeset
|
116 void print_on_error(outputStream* st, const char* prefix) const; |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8788
diff
changeset
|
117 |
| 342 | 118 // debugging |
| 20337 | 119 NOT_PRODUCT(bool covers(MemRegion rs) const;) |
| 120 }; | |
| 121 | |
| 122 class CMBitMapMappingChangedListener : public G1MappingChangedListener { | |
| 123 private: | |
| 124 CMBitMap* _bm; | |
| 125 public: | |
| 126 CMBitMapMappingChangedListener() : _bm(NULL) {} | |
| 127 | |
| 128 void set_bitmap(CMBitMap* bm) { _bm = bm; } | |
| 129 | |
| 20543 | 130 virtual void on_commit(uint start_idx, size_t num_regions, bool zero_filled); |
| 342 | 131 }; |
| 132 | |
| 133 class CMBitMap : public CMBitMapRO { | |
| 20337 | 134 private: |
| 135 CMBitMapMappingChangedListener _listener; | |
| 342 | 136 |
| 137 public: | |
| 20337 | 138 static size_t compute_size(size_t heap_size); |
| 139 // Returns the amount of bytes on the heap between two marks in the bitmap. | |
| 140 static size_t mark_distance(); | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
141 |
| 20337 | 142 CMBitMap() : CMBitMapRO(LogMinObjAlignment), _listener() { _listener.set_bitmap(this); } |
| 342 | 143 |
| 20337 | 144 // Initializes the underlying BitMap to cover the given area. |
| 145 void initialize(MemRegion heap, G1RegionToSpaceMapper* storage); | |
| 146 | |
| 147 // Write marks. | |
| 148 inline void mark(HeapWord* addr); | |
| 149 inline void clear(HeapWord* addr); | |
| 150 inline bool parMark(HeapWord* addr); | |
| 151 inline bool parClear(HeapWord* addr); | |
| 152 | |
| 342 | 153 void markRange(MemRegion mr); |
| 154 void clearRange(MemRegion mr); | |
| 155 | |
| 156 // Starting at the bit corresponding to "addr" (inclusive), find the next | |
| 157 // "1" bit, if any. This bit starts some run of consecutive "1"'s; find | |
| 158 // the end of this run (stopping at "end_addr"). Return the MemRegion | |
| 159 // covering from the start of the region corresponding to the first bit | |
| 160 // of the run to the end of the region corresponding to the last bit of | |
| 161 // the run. If there is no "1" bit at or after "addr", return an empty | |
| 162 // MemRegion. | |
| 163 MemRegion getAndClearMarkedRegion(HeapWord* addr, HeapWord* end_addr); | |
| 20337 | 164 |
| 165 // Clear the whole mark bitmap. | |
| 166 void clearAll(); | |
| 342 | 167 }; |
| 168 | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
169 // Represents a marking stack used by ConcurrentMarking in the G1 collector. |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
342
diff
changeset
|
170 class CMMarkStack VALUE_OBJ_CLASS_SPEC { |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
171 VirtualSpace _virtual_space; // Underlying backing store for actual stack |
| 342 | 172 ConcurrentMark* _cm; |
|
8787
fa08949fe0cb
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
8733
diff
changeset
|
173 oop* _base; // bottom of stack |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
174 jint _index; // one more than last occupied index |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
175 jint _capacity; // max #elements |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
176 jint _saved_index; // value of _index saved at start of GC |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
177 NOT_PRODUCT(jint _max_depth;) // max depth plumbed during run |
| 342 | 178 |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
179 bool _overflow; |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
180 bool _should_expand; |
| 342 | 181 DEBUG_ONLY(bool _drain_in_progress;) |
| 182 DEBUG_ONLY(bool _drain_in_progress_yields;) | |
| 183 | |
| 184 public: | |
| 185 CMMarkStack(ConcurrentMark* cm); | |
| 186 ~CMMarkStack(); | |
| 187 | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
188 #ifndef PRODUCT |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
189 jint max_depth() const { |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
190 return _max_depth; |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
191 } |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
192 #endif |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
193 |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
194 bool allocate(size_t capacity); |
| 342 | 195 |
| 196 oop pop() { | |
| 197 if (!isEmpty()) { | |
| 198 return _base[--_index] ; | |
| 199 } | |
| 200 return NULL; | |
| 201 } | |
| 202 | |
| 203 // If overflow happens, don't do the push, and record the overflow. | |
| 204 // *Requires* that "ptr" is already marked. | |
| 205 void push(oop ptr) { | |
| 206 if (isFull()) { | |
| 207 // Record overflow. | |
| 208 _overflow = true; | |
| 209 return; | |
| 210 } else { | |
| 211 _base[_index++] = ptr; | |
| 212 NOT_PRODUCT(_max_depth = MAX2(_max_depth, _index)); | |
| 213 } | |
| 214 } | |
| 215 // Non-block impl. Note: concurrency is allowed only with other | |
| 216 // "par_push" operations, not with "pop" or "drain". We would need | |
| 217 // parallel versions of them if such concurrency was desired. | |
| 218 void par_push(oop ptr); | |
| 219 | |
| 220 // Pushes the first "n" elements of "ptr_arr" on the stack. | |
| 221 // Non-block impl. Note: concurrency is allowed only with other | |
| 222 // "par_adjoin_arr" or "push" operations, not with "pop" or "drain". | |
| 223 void par_adjoin_arr(oop* ptr_arr, int n); | |
| 224 | |
| 225 // Pushes the first "n" elements of "ptr_arr" on the stack. | |
| 226 // Locking impl: concurrency is allowed only with | |
| 227 // "par_push_arr" and/or "par_pop_arr" operations, which use the same | |
| 228 // locking strategy. | |
| 229 void par_push_arr(oop* ptr_arr, int n); | |
| 230 | |
| 231 // If returns false, the array was empty. Otherwise, removes up to "max" | |
| 232 // elements from the stack, and transfers them to "ptr_arr" in an | |
| 233 // unspecified order. The actual number transferred is given in "n" ("n | |
| 234 // == 0" is deliberately redundant with the return value.) Locking impl: | |
| 235 // concurrency is allowed only with "par_push_arr" and/or "par_pop_arr" | |
| 236 // operations, which use the same locking strategy. | |
| 237 bool par_pop_arr(oop* ptr_arr, int max, int* n); | |
| 238 | |
| 239 // Drain the mark stack, applying the given closure to all fields of | |
| 240 // objects on the stack. (That is, continue until the stack is empty, | |
| 241 // even if closure applications add entries to the stack.) The "bm" | |
| 242 // argument, if non-null, may be used to verify that only marked objects | |
| 243 // are on the mark stack. If "yield_after" is "true", then the | |
| 244 // concurrent marker performing the drain offers to yield after | |
| 245 // processing each object. If a yield occurs, stops the drain operation | |
| 246 // and returns false. Otherwise, returns true. | |
| 247 template<class OopClosureClass> | |
| 248 bool drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after = false); | |
| 249 | |
| 250 bool isEmpty() { return _index == 0; } | |
| 251 bool isFull() { return _index == _capacity; } | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
252 int maxElems() { return _capacity; } |
| 342 | 253 |
| 254 bool overflow() { return _overflow; } | |
| 255 void clear_overflow() { _overflow = false; } | |
| 256 | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
257 bool should_expand() const { return _should_expand; } |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
258 void set_should_expand(); |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
259 |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
260 // Expand the stack, typically in response to an overflow condition |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
261 void expand(); |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
262 |
| 342 | 263 int size() { return _index; } |
| 264 | |
| 265 void setEmpty() { _index = 0; clear_overflow(); } | |
| 266 | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
267 // Record the current index. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
268 void note_start_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
269 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
270 // Make sure that we have not added any entries to the stack during GC. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
271 void note_end_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
272 |
| 342 | 273 // iterate over the oops in the mark stack, up to the bound recorded via |
| 274 // the call above. | |
| 275 void oops_do(OopClosure* f); | |
| 276 }; | |
| 277 | |
|
3316
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
278 class ForceOverflowSettings VALUE_OBJ_CLASS_SPEC { |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
279 private: |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
280 #ifndef PRODUCT |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
281 uintx _num_remaining; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
282 bool _force; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
283 #endif // !defined(PRODUCT) |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
284 |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
285 public: |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
286 void init() PRODUCT_RETURN; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
287 void update() PRODUCT_RETURN; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
288 bool should_force() PRODUCT_RETURN_( return false; ); |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
289 }; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
290 |
| 342 | 291 // this will enable a variety of different statistics per GC task |
| 292 #define _MARKING_STATS_ 0 | |
| 293 // this will enable the higher verbose levels | |
| 294 #define _MARKING_VERBOSE_ 0 | |
| 295 | |
| 296 #if _MARKING_STATS_ | |
| 297 #define statsOnly(statement) \ | |
| 298 do { \ | |
| 299 statement ; \ | |
| 300 } while (0) | |
| 301 #else // _MARKING_STATS_ | |
| 302 #define statsOnly(statement) \ | |
| 303 do { \ | |
| 304 } while (0) | |
| 305 #endif // _MARKING_STATS_ | |
| 306 | |
| 307 typedef enum { | |
| 308 no_verbose = 0, // verbose turned off | |
| 309 stats_verbose, // only prints stats at the end of marking | |
| 310 low_verbose, // low verbose, mostly per region and per major event | |
| 311 medium_verbose, // a bit more detailed than low | |
| 312 high_verbose // per object verbose | |
| 313 } CMVerboseLevel; | |
| 314 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
315 class YoungList; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
316 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
317 // Root Regions are regions that are not empty at the beginning of a |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
318 // marking cycle and which we might collect during an evacuation pause |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
319 // while the cycle is active. Given that, during evacuation pauses, we |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
320 // do not copy objects that are explicitly marked, what we have to do |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
321 // for the root regions is to scan them and mark all objects reachable |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
322 // from them. According to the SATB assumptions, we only need to visit |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
323 // each object once during marking. So, as long as we finish this scan |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
324 // before the next evacuation pause, we can copy the objects from the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
325 // root regions without having to mark them or do anything else to them. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
326 // |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
327 // Currently, we only support root region scanning once (at the start |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
328 // of the marking cycle) and the root regions are all the survivor |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
329 // regions populated during the initial-mark pause. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
330 class CMRootRegions VALUE_OBJ_CLASS_SPEC { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
331 private: |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
332 YoungList* _young_list; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
333 ConcurrentMark* _cm; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
334 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
335 volatile bool _scan_in_progress; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
336 volatile bool _should_abort; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
337 HeapRegion* volatile _next_survivor; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
338 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
339 public: |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
340 CMRootRegions(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
341 // We actually do most of the initialization in this method. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
342 void init(G1CollectedHeap* g1h, ConcurrentMark* cm); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
343 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
344 // Reset the claiming / scanning of the root regions. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
345 void prepare_for_scan(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
346 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
347 // Forces get_next() to return NULL so that the iteration aborts early. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
348 void abort() { _should_abort = true; } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
349 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
350 // Return true if the CM thread are actively scanning root regions, |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
351 // false otherwise. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
352 bool scan_in_progress() { return _scan_in_progress; } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
353 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
354 // Claim the next root region to scan atomically, or return NULL if |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
355 // all have been claimed. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
356 HeapRegion* claim_next(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
357 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
358 // Flag that we're done with root region scanning and notify anyone |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
359 // who's waiting on it. If aborted is false, assume that all regions |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
360 // have been claimed. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
361 void scan_finished(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
362 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
363 // If CM threads are still scanning root regions, wait until they |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
364 // are done. Return true if we had to wait, false otherwise. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
365 bool wait_until_scan_finished(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
366 }; |
| 342 | 367 |
| 368 class ConcurrentMarkThread; | |
| 369 | |
| 6197 | 370 class ConcurrentMark: public CHeapObj<mtGC> { |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
371 friend class CMMarkStack; |
| 342 | 372 friend class ConcurrentMarkThread; |
| 373 friend class CMTask; | |
| 374 friend class CMBitMapClosure; | |
| 375 friend class CMGlobalObjectClosure; | |
| 376 friend class CMRemarkTask; | |
| 377 friend class CMConcurrentMarkingTask; | |
| 378 friend class G1ParNoteEndTask; | |
| 379 friend class CalcLiveObjectsClosure; | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3867
diff
changeset
|
380 friend class G1CMRefProcTaskProxy; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3867
diff
changeset
|
381 friend class G1CMRefProcTaskExecutor; |
|
8014
f90b9bceb8e5
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
8008
diff
changeset
|
382 friend class G1CMKeepAliveAndDrainClosure; |
|
f90b9bceb8e5
8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents:
8008
diff
changeset
|
383 friend class G1CMDrainMarkingStackClosure; |
| 342 | 384 |
| 385 protected: | |
| 386 ConcurrentMarkThread* _cmThread; // the thread doing the work | |
| 387 G1CollectedHeap* _g1h; // the heap. | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
388 uint _parallel_marking_threads; // the number of marking |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
389 // threads we're use |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
390 uint _max_parallel_marking_threads; // max number of marking |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
391 // threads we'll ever use |
| 342 | 392 double _sleep_factor; // how much we have to sleep, with |
| 393 // respect to the work we just did, to | |
| 394 // meet the marking overhead goal | |
| 395 double _marking_task_overhead; // marking target overhead for | |
| 396 // a single task | |
| 397 | |
| 398 // same as the two above, but for the cleanup task | |
| 399 double _cleanup_sleep_factor; | |
| 400 double _cleanup_task_overhead; | |
| 401 | |
| 2152 | 402 FreeRegionList _cleanup_list; |
| 342 | 403 |
|
4828
851b58c26def
7130334: G1: Change comments and error messages that refer to CMS in g1/concurrentMark.cpp/hpp
brutisso
parents:
4827
diff
changeset
|
404 // Concurrent marking support structures |
| 342 | 405 CMBitMap _markBitMap1; |
| 406 CMBitMap _markBitMap2; | |
| 407 CMBitMapRO* _prevMarkBitMap; // completed mark bitmap | |
| 408 CMBitMap* _nextMarkBitMap; // under-construction mark bitmap | |
| 409 | |
| 410 BitMap _region_bm; | |
| 411 BitMap _card_bm; | |
| 412 | |
| 413 // Heap bounds | |
| 414 HeapWord* _heap_start; | |
| 415 HeapWord* _heap_end; | |
| 416 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
417 // Root region tracking and claiming. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
418 CMRootRegions _root_regions; |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
419 |
| 342 | 420 // For gray objects |
| 421 CMMarkStack _markStack; // Grey objects behind global finger. | |
| 422 HeapWord* volatile _finger; // the global finger, region aligned, | |
| 423 // always points to the end of the | |
| 424 // last claimed region | |
| 425 | |
| 426 // marking tasks | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
427 uint _max_worker_id;// maximum worker id |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
428 uint _active_tasks; // task num currently active |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
429 CMTask** _tasks; // task queue array (max_worker_id len) |
| 342 | 430 CMTaskQueueSet* _task_queues; // task queue set |
| 431 ParallelTaskTerminator _terminator; // for termination | |
| 432 | |
| 433 // Two sync barriers that are used to synchronise tasks when an | |
| 434 // overflow occurs. The algorithm is the following. All tasks enter | |
| 435 // the first one to ensure that they have all stopped manipulating | |
| 436 // the global data structures. After they exit it, they re-initialise | |
| 437 // their data structures and task 0 re-initialises the global data | |
| 438 // structures. Then, they enter the second sync barrier. This | |
| 439 // ensure, that no task starts doing work before all data | |
| 440 // structures (local and global) have been re-initialised. When they | |
| 441 // exit it, they are free to start working again. | |
| 442 WorkGangBarrierSync _first_overflow_barrier_sync; | |
| 443 WorkGangBarrierSync _second_overflow_barrier_sync; | |
| 444 | |
| 445 // this is set by any task, when an overflow on the global data | |
| 446 // structures is detected. | |
| 447 volatile bool _has_overflown; | |
| 448 // true: marking is concurrent, false: we're in remark | |
| 449 volatile bool _concurrent; | |
| 450 // set at the end of a Full GC so that marking aborts | |
| 451 volatile bool _has_aborted; | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17950
diff
changeset
|
452 GCId _aborted_gc_id; |
|
1835
4805b9f4779e
6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents:
1552
diff
changeset
|
453 |
| 342 | 454 // used when remark aborts due to an overflow to indicate that |
| 455 // another concurrent marking phase should start | |
| 456 volatile bool _restart_for_overflow; | |
| 457 | |
| 458 // This is true from the very start of concurrent marking until the | |
| 459 // point when all the tasks complete their work. It is really used | |
| 460 // to determine the points between the end of concurrent marking and | |
| 461 // time of remark. | |
| 462 volatile bool _concurrent_marking_in_progress; | |
| 463 | |
| 464 // verbose level | |
| 465 CMVerboseLevel _verbose_level; | |
| 466 | |
| 467 // All of these times are in ms. | |
| 468 NumberSeq _init_times; | |
| 469 NumberSeq _remark_times; | |
| 470 NumberSeq _remark_mark_times; | |
| 471 NumberSeq _remark_weak_ref_times; | |
| 472 NumberSeq _cleanup_times; | |
| 473 double _total_counting_time; | |
| 474 double _total_rs_scrub_time; | |
| 475 | |
| 476 double* _accum_task_vtime; // accumulated task vtime | |
| 477 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
478 FlexibleWorkGang* _parallel_workers; |
| 342 | 479 |
|
3316
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
480 ForceOverflowSettings _force_overflow_conc; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
481 ForceOverflowSettings _force_overflow_stw; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
482 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20192
diff
changeset
|
483 void weakRefsWorkParallelPart(BoolObjectClosure* is_alive, bool purged_classes); |
| 342 | 484 void weakRefsWork(bool clear_all_soft_refs); |
| 485 | |
| 486 void swapMarkBitMaps(); | |
| 487 | |
| 488 // It resets the global marking data structures, as well as the | |
| 489 // task local ones; should be called during initial mark. | |
| 490 void reset(); | |
|
7450
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
491 |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
492 // Resets all the marking data structures. Called when we have to restart |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
493 // marking or when marking completes (via set_non_marking_state below). |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
494 void reset_marking_state(bool clear_overflow = true); |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
495 |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
496 // We do this after we're done with marking so that the marking data |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
497 // structures are initialised to a sensible and predictable state. |
|
d275c3dc73e6
8004816: G1: Kitchensink failures after marking stack changes
johnc
parents:
7397
diff
changeset
|
498 void set_non_marking_state(); |
| 342 | 499 |
|
8788
e864cc14ca75
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
8787
diff
changeset
|
500 // Called to indicate how many threads are currently active. |
|
e864cc14ca75
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
8787
diff
changeset
|
501 void set_concurrency(uint active_tasks); |
|
e864cc14ca75
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
8787
diff
changeset
|
502 |
| 342 | 503 // It should be called to indicate which phase we're in (concurrent |
| 504 // mark or remark) and how many threads are currently active. | |
|
8788
e864cc14ca75
8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents:
8787
diff
changeset
|
505 void set_concurrency_and_phase(uint active_tasks, bool concurrent); |
| 342 | 506 |
| 507 // prints all gathered CM-related statistics | |
| 508 void print_stats(); | |
| 509 | |
| 2152 | 510 bool cleanup_list_is_empty() { |
| 511 return _cleanup_list.is_empty(); | |
| 512 } | |
| 513 | |
| 342 | 514 // accessor methods |
|
8008
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
515 uint parallel_marking_threads() const { return _parallel_marking_threads; } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
516 uint max_parallel_marking_threads() const { return _max_parallel_marking_threads;} |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
517 double sleep_factor() { return _sleep_factor; } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
518 double marking_task_overhead() { return _marking_task_overhead;} |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
519 double cleanup_sleep_factor() { return _cleanup_sleep_factor; } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
520 double cleanup_task_overhead() { return _cleanup_task_overhead;} |
| 342 | 521 |
|
8008
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
522 bool use_parallel_marking_threads() const { |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
523 assert(parallel_marking_threads() <= |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
524 max_parallel_marking_threads(), "sanity"); |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
525 assert((_parallel_workers == NULL && parallel_marking_threads() == 0) || |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
526 parallel_marking_threads() > 0, |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
527 "parallel workers not set up correctly"); |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
528 return _parallel_workers != NULL; |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
529 } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
530 |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
531 HeapWord* finger() { return _finger; } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
532 bool concurrent() { return _concurrent; } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
533 uint active_tasks() { return _active_tasks; } |
|
256d3f43c177
8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents:
7450
diff
changeset
|
534 ParallelTaskTerminator* terminator() { return &_terminator; } |
| 342 | 535 |
| 536 // It claims the next available region to be scanned by a marking | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
537 // task/thread. It might return NULL if the next region is empty or |
|
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
538 // we have run out of regions. In the latter case, out_of_regions() |
| 342 | 539 // determines whether we've really run out of regions or the task |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
540 // should call claim_region() again. This might seem a bit |
| 342 | 541 // awkward. Originally, the code was written so that claim_region() |
| 542 // either successfully returned with a non-empty region or there | |
| 543 // were no more regions to be claimed. The problem with this was | |
| 544 // that, in certain circumstances, it iterated over large chunks of | |
| 545 // the heap finding only empty regions and, while it was working, it | |
| 546 // was preventing the calling task to call its regular clock | |
| 547 // method. So, this way, each task will spend very little time in | |
| 548 // claim_region() and is allowed to call the regular clock method | |
| 549 // frequently. | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
550 HeapRegion* claim_region(uint worker_id); |
| 342 | 551 |
|
17950
8a140676873f
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
17736
diff
changeset
|
552 // It determines whether we've run out of regions to scan. Note that |
|
8a140676873f
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
17736
diff
changeset
|
553 // the finger can point past the heap end in case the heap was expanded |
|
8a140676873f
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
17736
diff
changeset
|
554 // to satisfy an allocation without doing a GC. This is fine, because all |
|
8a140676873f
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
17736
diff
changeset
|
555 // objects in those regions will be considered live anyway because of |
|
8a140676873f
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
17736
diff
changeset
|
556 // SATB guarantees (i.e. their TAMS will be equal to bottom). |
|
8a140676873f
8040804: G1: Concurrent mark stuck in loop calling os::elapsedVTime()
pliden
parents:
17736
diff
changeset
|
557 bool out_of_regions() { return _finger >= _heap_end; } |
| 342 | 558 |
| 559 // Returns the task with the given id | |
| 560 CMTask* task(int id) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
561 assert(0 <= id && id < (int) _active_tasks, |
|
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
562 "task id not within active bounds"); |
| 342 | 563 return _tasks[id]; |
| 564 } | |
| 565 | |
| 566 // Returns the task queue with the given id | |
| 567 CMTaskQueue* task_queue(int id) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
568 assert(0 <= id && id < (int) _active_tasks, |
|
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
569 "task queue id not within active bounds"); |
| 342 | 570 return (CMTaskQueue*) _task_queues->queue(id); |
| 571 } | |
| 572 | |
| 573 // Returns the task queue set | |
| 574 CMTaskQueueSet* task_queues() { return _task_queues; } | |
| 575 | |
| 576 // Access / manipulation of the overflow flag which is set to | |
|
5988
2a0172480595
7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents:
4837
diff
changeset
|
577 // indicate that the global stack has overflown |
| 342 | 578 bool has_overflown() { return _has_overflown; } |
| 579 void set_has_overflown() { _has_overflown = true; } | |
| 580 void clear_has_overflown() { _has_overflown = false; } | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
581 bool restart_for_overflow() { return _restart_for_overflow; } |
| 342 | 582 |
| 583 // Methods to enter the two overflow sync barriers | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
584 void enter_first_sync_barrier(uint worker_id); |
|
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
585 void enter_second_sync_barrier(uint worker_id); |
| 342 | 586 |
|
3316
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
587 ForceOverflowSettings* force_overflow_conc() { |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
588 return &_force_overflow_conc; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
589 } |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
590 |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
591 ForceOverflowSettings* force_overflow_stw() { |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
592 return &_force_overflow_stw; |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
593 } |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
594 |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
595 ForceOverflowSettings* force_overflow() { |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
596 if (concurrent()) { |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
597 return force_overflow_conc(); |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
598 } else { |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
599 return force_overflow_stw(); |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
600 } |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
601 } |
|
cd8e33b2a8ad
7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents:
2435
diff
changeset
|
602 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
603 // Live Data Counting data structures... |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
604 // These data structures are initialized at the start of |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
605 // marking. They are written to while marking is active. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
606 // They are aggregated during remark; the aggregated values |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
607 // are then used to populate the _region_bm, _card_bm, and |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
608 // the total live bytes, which are then subsequently updated |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
609 // during cleanup. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
610 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
611 // An array of bitmaps (one bit map per task). Each bitmap |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
612 // is used to record the cards spanned by the live objects |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
613 // marked by that task/worker. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
614 BitMap* _count_card_bitmaps; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
615 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
616 // Used to record the number of marked live bytes |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
617 // (for each region, by worker thread). |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
618 size_t** _count_marked_bytes; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
619 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
620 // Card index of the bottom of the G1 heap. Used for biasing indices into |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
621 // the card bitmaps. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
622 intptr_t _heap_bottom_card_num; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
623 |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
624 // Set to true when initialization is complete |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
625 bool _completed_initialization; |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
626 |
| 342 | 627 public: |
| 628 // Manipulation of the global mark stack. | |
| 629 // Notice that the first mark_stack_push is CAS-based, whereas the | |
| 630 // two below are Mutex-based. This is OK since the first one is only | |
| 631 // called during evacuation pauses and doesn't compete with the | |
| 632 // other two (which are called by the marking tasks during | |
| 633 // concurrent marking or remark). | |
| 634 bool mark_stack_push(oop p) { | |
| 635 _markStack.par_push(p); | |
| 636 if (_markStack.overflow()) { | |
| 637 set_has_overflown(); | |
| 638 return false; | |
| 639 } | |
| 640 return true; | |
| 641 } | |
| 642 bool mark_stack_push(oop* arr, int n) { | |
| 643 _markStack.par_push_arr(arr, n); | |
| 644 if (_markStack.overflow()) { | |
| 645 set_has_overflown(); | |
| 646 return false; | |
| 647 } | |
| 648 return true; | |
| 649 } | |
| 650 void mark_stack_pop(oop* arr, int max, int* n) { | |
| 651 _markStack.par_pop_arr(arr, max, n); | |
| 652 } | |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
653 size_t mark_stack_size() { return _markStack.size(); } |
| 342 | 654 size_t partial_mark_stack_size_target() { return _markStack.maxElems()/3; } |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
655 bool mark_stack_overflow() { return _markStack.overflow(); } |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
656 bool mark_stack_empty() { return _markStack.isEmpty(); } |
| 342 | 657 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
658 CMRootRegions* root_regions() { return &_root_regions; } |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
659 |
| 342 | 660 bool concurrent_marking_in_progress() { |
| 661 return _concurrent_marking_in_progress; | |
| 662 } | |
| 663 void set_concurrent_marking_in_progress() { | |
| 664 _concurrent_marking_in_progress = true; | |
| 665 } | |
| 666 void clear_concurrent_marking_in_progress() { | |
| 667 _concurrent_marking_in_progress = false; | |
| 668 } | |
| 669 | |
| 670 void update_accum_task_vtime(int i, double vtime) { | |
| 671 _accum_task_vtime[i] += vtime; | |
| 672 } | |
| 673 | |
| 674 double all_task_accum_vtime() { | |
| 675 double ret = 0.0; | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
676 for (uint i = 0; i < _max_worker_id; ++i) |
| 342 | 677 ret += _accum_task_vtime[i]; |
| 678 return ret; | |
| 679 } | |
| 680 | |
| 681 // Attempts to steal an object from the task queues of other tasks | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
682 bool try_stealing(uint worker_id, int* hash_seed, oop& obj) { |
|
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
683 return _task_queues->steal(worker_id, hash_seed, obj); |
| 342 | 684 } |
| 685 | |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
686 ConcurrentMark(G1CollectedHeap* g1h, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
687 G1RegionToSpaceMapper* prev_bitmap_storage, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
688 G1RegionToSpaceMapper* next_bitmap_storage); |
| 342 | 689 ~ConcurrentMark(); |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
690 |
| 342 | 691 ConcurrentMarkThread* cmThread() { return _cmThread; } |
| 692 | |
| 693 CMBitMapRO* prevMarkBitMap() const { return _prevMarkBitMap; } | |
| 694 CMBitMap* nextMarkBitMap() const { return _nextMarkBitMap; } | |
| 695 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
696 // Returns the number of GC threads to be used in a concurrent |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
697 // phase based on the number of GC threads being used in a STW |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
698 // phase. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
699 uint scale_parallel_threads(uint n_par_threads); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
700 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
701 // Calculates the number of GC threads to be used in a concurrent phase. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
702 uint calc_parallel_marking_threads(); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3979
diff
changeset
|
703 |
| 342 | 704 // The following three are interaction between CM and |
| 705 // G1CollectedHeap | |
| 706 | |
| 707 // This notifies CM that a root during initial-mark needs to be | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
708 // grayed. It is MT-safe. word_size is the size of the object in |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
709 // words. It is passed explicitly as sometimes we cannot calculate |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
710 // it from the given object because it might be in an inconsistent |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
711 // state (e.g., in to-space and being copied). So the caller is |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
712 // responsible for dealing with this issue (e.g., get the size from |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
713 // the from-space image when the to-space image might be |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
714 // inconsistent) and always passing the size. hr is the region that |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
715 // contains the object and it's passed optionally from callers who |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
716 // might already have it (no point in recalculating it). |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
717 inline void grayRoot(oop obj, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
718 size_t word_size, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
719 uint worker_id, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
720 HeapRegion* hr = NULL); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
721 |
| 1388 | 722 // It iterates over the heap and for each object it comes across it |
| 723 // will dump the contents of its reference fields, as well as | |
| 724 // liveness information for the object and its referents. The dump | |
| 725 // will be written to a file with the following name: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
726 // G1PrintReachableBaseFile + "." + str. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
727 // vo decides whether the prev (vo == UsePrevMarking), the next |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
728 // (vo == UseNextMarking) marking information, or the mark word |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
729 // (vo == UseMarkWord) will be used to determine the liveness of |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
730 // each object / referent. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
731 // If all is true, all objects in the heap will be dumped, otherwise |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
732 // only the live ones. In the dump the following symbols / breviations |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3771
diff
changeset
|
733 // are used: |
| 1388 | 734 // M : an explicitly live object (its bitmap bit is set) |
| 735 // > : an implicitly live object (over tams) | |
| 736 // O : an object outside the G1 heap (typically: in the perm gen) | |
| 737 // NOT : a reference field whose referent is not live | |
| 738 // AND MARKED : indicates that an object is both explicitly and | |
| 739 // implicitly live (it should be one or the other, not both) | |
| 740 void print_reachable(const char* str, | |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
741 VerifyOption vo, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
742 bool all) PRODUCT_RETURN; |
| 342 | 743 |
| 744 // Clear the next marking bitmap (will be called concurrently). | |
| 745 void clearNextBitmap(); | |
| 746 | |
| 20337 | 747 // Return whether the next mark bitmap has no marks set. To be used for assertions |
| 748 // only. Will not yield to pause requests. | |
|
20293
7df07d855c8e
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
20278
diff
changeset
|
749 bool nextMarkBitmapIsClear(); |
|
7df07d855c8e
8048085: Aborting marking just before remark results in useless additional clearing of the next mark bitmap
tschatzl
parents:
20278
diff
changeset
|
750 |
| 342 | 751 // These two do the work that needs to be done before and after the |
| 752 // initial root checkpoint. Since this checkpoint can be done at two | |
| 753 // different points (i.e. an explicit pause or piggy-backed on a | |
| 754 // young collection), then it's nice to be able to easily share the | |
| 755 // pre/post code. It might be the case that we can put everything in | |
| 756 // the post method. TP | |
| 757 void checkpointRootsInitialPre(); | |
| 758 void checkpointRootsInitialPost(); | |
| 759 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
760 // Scan all the root regions and mark everything reachable from |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
761 // them. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
762 void scanRootRegions(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
763 |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
764 // Scan a single root region and mark everything reachable from it. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
765 void scanRootRegion(HeapRegion* hr, uint worker_id); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
766 |
| 342 | 767 // Do concurrent phase of marking, to a tentative transitive closure. |
| 768 void markFromRoots(); | |
| 769 | |
| 770 void checkpointRootsFinal(bool clear_all_soft_refs); | |
| 771 void checkpointRootsFinalWork(); | |
| 772 void cleanup(); | |
| 773 void completeCleanup(); | |
| 774 | |
| 775 // Mark in the previous bitmap. NB: this is usually read-only, so use | |
| 776 // this carefully! | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
777 inline void markPrev(oop p); |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
778 |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
779 // Clears marks for all objects in the given range, for the prev or |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
780 // next bitmaps. NB: the previous bitmap is usually |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
781 // read-only, so use this carefully! |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
782 void clearRangePrevBitmap(MemRegion mr); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
783 void clearRangeNextBitmap(MemRegion mr); |
| 342 | 784 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
785 // Notify data structures that a GC has started. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
786 void note_start_of_gc() { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
787 _markStack.note_start_of_gc(); |
| 342 | 788 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
789 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
790 // Notify data structures that a GC is finished. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
791 void note_end_of_gc() { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
792 _markStack.note_end_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
793 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
794 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
795 // Verify that there are no CSet oops on the stacks (taskqueues / |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
796 // global mark stack), enqueued SATB buffers, per-thread SATB |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
797 // buffers, and fingers (global / per-task). The boolean parameters |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
798 // decide which of the above data structures to verify. If marking |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
799 // is not in progress, it's a no-op. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
800 void verify_no_cset_oops(bool verify_stacks, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
801 bool verify_enqueued_buffers, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
802 bool verify_thread_buffers, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
803 bool verify_fingers) PRODUCT_RETURN; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
804 |
| 342 | 805 bool isPrevMarked(oop p) const { |
| 806 assert(p != NULL && p->is_oop(), "expected an oop"); | |
| 807 HeapWord* addr = (HeapWord*)p; | |
| 808 assert(addr >= _prevMarkBitMap->startWord() || | |
| 809 addr < _prevMarkBitMap->endWord(), "in a region"); | |
| 810 | |
| 811 return _prevMarkBitMap->isMarked(addr); | |
| 812 } | |
| 813 | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
814 inline bool do_yield_check(uint worker_i = 0); |
| 342 | 815 |
| 816 // Called to abort the marking cycle after a Full GC takes palce. | |
| 817 void abort(); | |
| 818 | |
| 10405 | 819 bool has_aborted() { return _has_aborted; } |
| 820 | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17950
diff
changeset
|
821 const GCId& concurrent_gc_id(); |
|
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17950
diff
changeset
|
822 |
| 342 | 823 // This prints the global/local fingers. It is used for debugging. |
| 824 NOT_PRODUCT(void print_finger();) | |
| 825 | |
| 826 void print_summary_info(); | |
| 827 | |
| 1019 | 828 void print_worker_threads_on(outputStream* st) const; |
| 829 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8788
diff
changeset
|
830 void print_on_error(outputStream* st) const; |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8788
diff
changeset
|
831 |
| 342 | 832 // The following indicate whether a given verbose level has been |
| 833 // set. Notice that anything above stats is conditional to | |
| 834 // _MARKING_VERBOSE_ having been set to 1 | |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
835 bool verbose_stats() { |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
836 return _verbose_level >= stats_verbose; |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
837 } |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
838 bool verbose_low() { |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
839 return _MARKING_VERBOSE_ && _verbose_level >= low_verbose; |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
840 } |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
841 bool verbose_medium() { |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
842 return _MARKING_VERBOSE_ && _verbose_level >= medium_verbose; |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
843 } |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
844 bool verbose_high() { |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
845 return _MARKING_VERBOSE_ && _verbose_level >= high_verbose; |
|
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
846 } |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
847 |
|
6812
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
848 // Liveness counting |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
849 |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
850 // Utility routine to set an exclusive range of cards on the given |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
851 // card liveness bitmap |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
852 inline void set_card_bitmap_range(BitMap* card_bm, |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
853 BitMap::idx_t start_idx, |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
854 BitMap::idx_t end_idx, |
|
988bf00cc564
7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents:
6197
diff
changeset
|
855 bool is_par); |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
856 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
857 // Returns the card number of the bottom of the G1 heap. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
858 // Used in biasing indices into accounting card bitmaps. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
859 intptr_t heap_bottom_card_num() const { |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
860 return _heap_bottom_card_num; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
861 } |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
862 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
863 // Returns the card bitmap for a given task or worker id. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
864 BitMap* count_card_bitmap_for(uint worker_id) { |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
865 assert(0 <= worker_id && worker_id < _max_worker_id, "oob"); |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
866 assert(_count_card_bitmaps != NULL, "uninitialized"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
867 BitMap* task_card_bm = &_count_card_bitmaps[worker_id]; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
868 assert(task_card_bm->size() == _card_bm.size(), "size mismatch"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
869 return task_card_bm; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
870 } |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
871 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
872 // Returns the array containing the marked bytes for each region, |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
873 // for the given worker or task id. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
874 size_t* count_marked_bytes_array_for(uint worker_id) { |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
875 assert(0 <= worker_id && worker_id < _max_worker_id, "oob"); |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
876 assert(_count_marked_bytes != NULL, "uninitialized"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
877 size_t* marked_bytes_array = _count_marked_bytes[worker_id]; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
878 assert(marked_bytes_array != NULL, "uninitialized"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
879 return marked_bytes_array; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
880 } |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
881 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
882 // Returns the index in the liveness accounting card table bitmap |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
883 // for the given address |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
884 inline BitMap::idx_t card_bitmap_index_for(HeapWord* addr); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
885 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
886 // Counts the size of the given memory region in the the given |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
887 // marked_bytes array slot for the given HeapRegion. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
888 // Sets the bits in the given card bitmap that are associated with the |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
889 // cards that are spanned by the memory region. |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
890 inline void count_region(MemRegion mr, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
891 HeapRegion* hr, |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
892 size_t* marked_bytes_array, |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
893 BitMap* task_card_bm); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
894 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
895 // Counts the given memory region in the task/worker counting |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
896 // data structures for the given worker id. |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
897 inline void count_region(MemRegion mr, HeapRegion* hr, uint worker_id); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
898 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
899 // Counts the given object in the given task/worker counting |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
900 // data structures. |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
901 inline void count_object(oop obj, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
902 HeapRegion* hr, |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
903 size_t* marked_bytes_array, |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
904 BitMap* task_card_bm); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
905 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
906 // Attempts to mark the given object and, if successful, counts |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
907 // the object in the given task/worker counting structures. |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
908 inline bool par_mark_and_count(oop obj, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
909 HeapRegion* hr, |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
910 size_t* marked_bytes_array, |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
911 BitMap* task_card_bm); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
912 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
913 // Attempts to mark the given object and, if successful, counts |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
914 // the object in the task/worker counting structures for the |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
915 // given worker id. |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
916 inline bool par_mark_and_count(oop obj, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
917 size_t word_size, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
918 HeapRegion* hr, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
919 uint worker_id); |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
920 |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
921 // Returns true if initialization was successfully completed. |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
922 bool completed_initialization() const { |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
923 return _completed_initialization; |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
924 } |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
6862
diff
changeset
|
925 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
926 protected: |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
927 // Clear all the per-task bitmaps and arrays used to store the |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
928 // counting data. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
929 void clear_all_count_data(); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
930 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
931 // Aggregates the counting data for each worker/task |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
932 // that was constructed while marking. Also sets |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
933 // the amount of marked bytes for each region and |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
934 // the top at concurrent mark count. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
935 void aggregate_count_data(); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
936 |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
937 // Verification routine |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
938 void verify_count_data(); |
| 342 | 939 }; |
| 940 | |
| 941 // A class representing a marking task. | |
| 942 class CMTask : public TerminatorTerminator { | |
| 943 private: | |
| 944 enum PrivateConstants { | |
| 945 // the regular clock call is called once the scanned words reaches | |
| 946 // this limit | |
| 947 words_scanned_period = 12*1024, | |
| 948 // the regular clock call is called once the number of visited | |
| 949 // references reaches this limit | |
| 950 refs_reached_period = 384, | |
| 951 // initial value for the hash seed, used in the work stealing code | |
| 952 init_hash_seed = 17, | |
| 953 // how many entries will be transferred between global stack and | |
| 954 // local queues | |
| 955 global_stack_transfer_size = 16 | |
| 956 }; | |
| 957 | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
958 uint _worker_id; |
| 342 | 959 G1CollectedHeap* _g1h; |
| 960 ConcurrentMark* _cm; | |
| 961 CMBitMap* _nextMarkBitMap; | |
| 962 // the task queue of this task | |
| 963 CMTaskQueue* _task_queue; | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
964 private: |
| 342 | 965 // the task queue set---needed for stealing |
| 966 CMTaskQueueSet* _task_queues; | |
| 967 // indicates whether the task has been claimed---this is only for | |
| 968 // debugging purposes | |
| 969 bool _claimed; | |
| 970 | |
| 971 // number of calls to this task | |
| 972 int _calls; | |
| 973 | |
| 974 // when the virtual timer reaches this time, the marking step should | |
| 975 // exit | |
| 976 double _time_target_ms; | |
| 977 // the start time of the current marking step | |
| 978 double _start_time_ms; | |
| 979 | |
| 980 // the oop closure used for iterations over oops | |
| 3771 | 981 G1CMOopClosure* _cm_oop_closure; |
| 342 | 982 |
| 983 // the region this task is scanning, NULL if we're not scanning any | |
| 984 HeapRegion* _curr_region; | |
| 985 // the local finger of this task, NULL if we're not scanning a region | |
| 986 HeapWord* _finger; | |
| 987 // limit of the region this task is scanning, NULL if we're not scanning one | |
| 988 HeapWord* _region_limit; | |
| 989 | |
| 990 // the number of words this task has scanned | |
| 991 size_t _words_scanned; | |
| 992 // When _words_scanned reaches this limit, the regular clock is | |
| 993 // called. Notice that this might be decreased under certain | |
| 994 // circumstances (i.e. when we believe that we did an expensive | |
| 995 // operation). | |
| 996 size_t _words_scanned_limit; | |
| 997 // the initial value of _words_scanned_limit (i.e. what it was | |
| 998 // before it was decreased). | |
| 999 size_t _real_words_scanned_limit; | |
| 1000 | |
| 1001 // the number of references this task has visited | |
| 1002 size_t _refs_reached; | |
| 1003 // When _refs_reached reaches this limit, the regular clock is | |
| 1004 // called. Notice this this might be decreased under certain | |
| 1005 // circumstances (i.e. when we believe that we did an expensive | |
| 1006 // operation). | |
| 1007 size_t _refs_reached_limit; | |
| 1008 // the initial value of _refs_reached_limit (i.e. what it was before | |
| 1009 // it was decreased). | |
| 1010 size_t _real_refs_reached_limit; | |
| 1011 | |
| 1012 // used by the work stealing stuff | |
| 1013 int _hash_seed; | |
| 1014 // if this is true, then the task has aborted for some reason | |
| 1015 bool _has_aborted; | |
| 1016 // set when the task aborts because it has met its time quota | |
|
2174
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2152
diff
changeset
|
1017 bool _has_timed_out; |
| 342 | 1018 // true when we're draining SATB buffers; this avoids the task |
| 1019 // aborting due to SATB buffers being available (as we're already | |
| 1020 // dealing with them) | |
| 1021 bool _draining_satb_buffers; | |
| 1022 | |
| 1023 // number sequence of past step times | |
| 1024 NumberSeq _step_times_ms; | |
| 1025 // elapsed time of this task | |
| 1026 double _elapsed_time_ms; | |
| 1027 // termination time of this task | |
| 1028 double _termination_time_ms; | |
| 1029 // when this task got into the termination protocol | |
| 1030 double _termination_start_time_ms; | |
| 1031 | |
| 1032 // true when the task is during a concurrent phase, false when it is | |
| 1033 // in the remark phase (so, in the latter case, we do not have to | |
| 1034 // check all the things that we have to check during the concurrent | |
| 1035 // phase, i.e. SATB buffer availability...) | |
| 1036 bool _concurrent; | |
| 1037 | |
| 1038 TruncatedSeq _marking_step_diffs_ms; | |
| 1039 | |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
1040 // Counting data structures. Embedding the task's marked_bytes_array |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
1041 // and card bitmap into the actual task saves having to go through |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
1042 // the ConcurrentMark object. |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
1043 size_t* _marked_bytes_array; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
1044 BitMap* _card_bm; |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4828
diff
changeset
|
1045 |
| 342 | 1046 // LOTS of statistics related with this task |
| 1047 #if _MARKING_STATS_ | |
| 1048 NumberSeq _all_clock_intervals_ms; | |
| 1049 double _interval_start_time_ms; | |
| 1050 | |
| 1051 int _aborted; | |
| 1052 int _aborted_overflow; | |
| 1053 int _aborted_cm_aborted; | |
| 1054 int _aborted_yield; | |
| 1055 int _aborted_timed_out; | |
| 1056 int _aborted_satb; | |
| 1057 int _aborted_termination; | |
| 1058 | |
| 1059 int _steal_attempts; | |
| 1060 int _steals; | |
| 1061 | |
| 1062 int _clock_due_to_marking; | |
| 1063 int _clock_due_to_scanning; | |
| 1064 | |
| 1065 int _local_pushes; | |
| 1066 int _local_pops; | |
| 1067 int _local_max_size; | |
| 1068 int _objs_scanned; | |
| 1069 | |
| 1070 int _global_pushes; | |
| 1071 int _global_pops; | |
| 1072 int _global_max_size; | |
| 1073 | |
| 1074 int _global_transfers_to; | |
| 1075 int _global_transfers_from; | |
| 1076 | |
| 1077 int _regions_claimed; | |
| 1078 int _objs_found_on_bitmap; | |
| 1079 | |
| 1080 int _satb_buffers_processed; | |
| 1081 #endif // _MARKING_STATS_ | |
| 1082 | |
| 1083 // it updates the local fields after this task has claimed | |
| 1084 // a new region to scan | |
| 1085 void setup_for_region(HeapRegion* hr); | |
| 1086 // it brings up-to-date the limit of the region | |
| 1087 void update_region_limit(); | |
| 1088 | |
| 1089 // called when either the words scanned or the refs visited limit | |
| 1090 // has been reached | |
| 1091 void reached_limit(); | |
| 1092 // recalculates the words scanned and refs visited limits | |
| 1093 void recalculate_limits(); | |
| 1094 // decreases the words scanned and refs visited limits when we reach | |
| 1095 // an expensive operation | |
| 1096 void decrease_limits(); | |
| 1097 // it checks whether the words scanned or refs visited reached their | |
| 1098 // respective limit and calls reached_limit() if they have | |
| 1099 void check_limits() { | |
| 1100 if (_words_scanned >= _words_scanned_limit || | |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
1101 _refs_reached >= _refs_reached_limit) { |
| 342 | 1102 reached_limit(); |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3772
diff
changeset
|
1103 } |
| 342 | 1104 } |
| 1105 // this is supposed to be called regularly during a marking step as | |
| 1106 // it checks a bunch of conditions that might cause the marking step | |
| 1107 // to abort | |
| 1108 void regular_clock_call(); | |
| 1109 bool concurrent() { return _concurrent; } | |
| 1110 | |
| 1111 public: | |
| 1112 // It resets the task; it should be called right at the beginning of | |
| 1113 // a marking phase. | |
| 1114 void reset(CMBitMap* _nextMarkBitMap); | |
| 1115 // it clears all the fields that correspond to a claimed region. | |
| 1116 void clear_region_fields(); | |
| 1117 | |
| 1118 void set_concurrent(bool concurrent) { _concurrent = concurrent; } | |
| 1119 | |
| 1120 // The main method of this class which performs a marking step | |
| 1121 // trying not to exceed the given duration. However, it might exit | |
| 1122 // prematurely, according to some conditions (i.e. SATB buffers are | |
| 1123 // available for processing). | |
|
8787
fa08949fe0cb
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
8733
diff
changeset
|
1124 void do_marking_step(double target_ms, |
|
fa08949fe0cb
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
8733
diff
changeset
|
1125 bool do_termination, |
|
fa08949fe0cb
8009536: G1: Apache Lucene hang during reference processing
johnc
parents:
8733
diff
changeset
|
1126 bool is_serial); |
| 342 | 1127 |
| 1128 // These two calls start and stop the timer | |
| 1129 void record_start_time() { | |
| 1130 _elapsed_time_ms = os::elapsedTime() * 1000.0; | |
| 1131 } | |
| 1132 void record_end_time() { | |
| 1133 _elapsed_time_ms = os::elapsedTime() * 1000.0 - _elapsed_time_ms; | |
| 1134 } | |
| 1135 | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
1136 // returns the worker ID associated with this task. |
|
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6812
diff
changeset
|
1137 uint worker_id() { return _worker_id; } |
| 342 | 1138 |
| 1139 // From TerminatorTerminator. It determines whether this task should | |
| 1140 // exit the termination protocol after it's entered it. | |
| 1141 virtual bool should_exit_termination(); | |
| 1142 | |
|
3378
69293e516993
7041440: G1: assert(obj->is_oop_or_null(true )) failed: Error #
johnc
parents:
3316
diff
changeset
|
1143 // Resets the local region fields after a task has finished scanning a |
|
69293e516993
7041440: G1: assert(obj->is_oop_or_null(true )) failed: Error #
johnc
parents:
3316
diff
changeset
|
1144 // region; or when they have become stale as a result of the region |
|
69293e516993
7041440: G1: assert(obj->is_oop_or_null(true )) failed: Error #
johnc
parents:
3316
diff
changeset
|
1145 // being evacuated. |
|
69293e516993
7041440: G1: assert(obj->is_oop_or_null(true )) failed: Error #
johnc
parents:
3316
diff
changeset
|
1146 void giveup_current_region(); |
|
69293e516993
7041440: G1: assert(obj->is_oop_or_null(true )) failed: Error #
johnc
parents:
3316
diff
changeset
|
1147 |
| 342 | 1148 HeapWord* finger() { return _finger; } |
| 1149 | |
| 1150 bool has_aborted() { return _has_aborted; } | |
| 1151 void set_has_aborted() { _has_aborted = true; } | |
| 1152 void clear_has_aborted() { _has_aborted = false; } | |
|
2174
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2152
diff
changeset
|
1153 bool has_timed_out() { return _has_timed_out; } |
|
234761c55641
6608385: G1: need to support parallel reference processing
johnc
parents:
2152
diff
changeset
|
1154 bool claimed() { return _claimed; } |
| 342 | 1155 |
| 3771 | 1156 void set_cm_oop_closure(G1CMOopClosure* cm_oop_closure); |
| 342 | 1157 |
| 1158 // It grays the object by marking it and, if necessary, pushing it | |
| 1159 // on the local queue | |
| 3771 | 1160 inline void deal_with_reference(oop obj); |
| 342 | 1161 |
| 1162 // It scans an object and visits its children. | |
| 3771 | 1163 void scan_object(oop obj); |
| 342 | 1164 |
| 1165 // It pushes an object on the local queue. | |
| 3771 | 1166 inline void push(oop obj); |
| 342 | 1167 |
| 1168 // These two move entries to/from the global stack. | |
| 1169 void move_entries_to_global_stack(); | |
| 1170 void get_entries_from_global_stack(); | |
| 1171 | |
| 1172 // It pops and scans objects from the local queue. If partially is | |
| 1173 // true, then it stops when the queue size is of a given limit. If | |
| 1174 // partially is false, then it stops when the queue is empty. | |
| 1175 void drain_local_queue(bool partially); | |
| 1176 // It moves entries from the global stack to the local queue and | |
| 1177 // drains the local queue. If partially is true, then it stops when | |
| 1178 // both the global stack and the local queue reach a given size. If | |
| 1179 // partially if false, it tries to empty them totally. | |
| 1180 void drain_global_stack(bool partially); | |
| 1181 // It keeps picking SATB buffers and processing them until no SATB | |
| 1182 // buffers are available. | |
| 1183 void drain_satb_buffers(); | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4728
diff
changeset
|
1184 |
| 342 | 1185 // moves the local finger to a new location |
| 1186 inline void move_finger_to(HeapWord* new_finger) { | |
|
1023
11d4857fe5e1
6888619: G1: too many guarantees in concurrent marking
tonyp
parents:
1019
diff
changeset
|
1187 assert(new_finger >= _finger && new_finger < _region_limit, "invariant"); |
| 342 | 1188 _finger = new_finger; |
| 1189 } | |
| 1190 | |
|
20380
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
1191 CMTask(uint worker_id, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
1192 ConcurrentMark *cm, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
1193 size_t* marked_bytes, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
1194 BitMap* card_bm, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
1195 CMTaskQueue* task_queue, |
|
9337d0e7ea4f
8055919: Remove dead code in G1 concurrent marking code
tschatzl
parents:
20337
diff
changeset
|
1196 CMTaskQueueSet* task_queues); |
| 342 | 1197 |
| 1198 // it prints statistics associated with this task | |
| 1199 void print_stats(); | |
| 1200 | |
| 1201 #if _MARKING_STATS_ | |
| 1202 void increase_objs_found_on_bitmap() { ++_objs_found_on_bitmap; } | |
| 1203 #endif // _MARKING_STATS_ | |
| 1204 }; | |
| 1972 | 1205 |
|
2435
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1206 // Class that's used to to print out per-region liveness |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1207 // information. It's currently used at the end of marking and also |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1208 // after we sort the old regions at the end of the cleanup operation. |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1209 class G1PrintRegionLivenessInfoClosure: public HeapRegionClosure { |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1210 private: |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1211 outputStream* _out; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1212 |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1213 // Accumulators for these values. |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1214 size_t _total_used_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1215 size_t _total_capacity_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1216 size_t _total_prev_live_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1217 size_t _total_next_live_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1218 |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1219 // These are set up when we come across a "stars humongous" region |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1220 // (as this is where most of this information is stored, not in the |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1221 // subsequent "continues humongous" regions). After that, for every |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1222 // region in a given humongous region series we deduce the right |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1223 // values for it by simply subtracting the appropriate amount from |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1224 // these fields. All these values should reach 0 after we've visited |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1225 // the last region in the series. |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1226 size_t _hum_used_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1227 size_t _hum_capacity_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1228 size_t _hum_prev_live_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1229 size_t _hum_next_live_bytes; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1230 |
|
10290
05a17f270c7e
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
9076
diff
changeset
|
1231 // Accumulator for the remembered set size |
|
05a17f270c7e
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
9076
diff
changeset
|
1232 size_t _total_remset_bytes; |
|
05a17f270c7e
8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents:
9076
diff
changeset
|
1233 |
| 12080 | 1234 // Accumulator for strong code roots memory size |
| 1235 size_t _total_strong_code_roots_bytes; | |
| 1236 | |
|
2435
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1237 static double perc(size_t val, size_t total) { |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1238 if (total == 0) { |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1239 return 0.0; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1240 } else { |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1241 return 100.0 * ((double) val / (double) total); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1242 } |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1243 } |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1244 |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1245 static double bytes_to_mb(size_t val) { |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1246 return (double) val / (double) M; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1247 } |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1248 |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1249 // See the .cpp file. |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1250 size_t get_hum_bytes(size_t* hum_bytes); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1251 void get_hum_bytes(size_t* used_bytes, size_t* capacity_bytes, |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1252 size_t* prev_live_bytes, size_t* next_live_bytes); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1253 |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1254 public: |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1255 // The header and footer are printed in the constructor and |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1256 // destructor respectively. |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1257 G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1258 virtual bool doHeapRegion(HeapRegion* r); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1259 ~G1PrintRegionLivenessInfoClosure(); |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1260 }; |
|
371bbc844bf1
7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents:
2174
diff
changeset
|
1261 |
| 1972 | 1262 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP |