Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/heapRegion.cpp @ 17833:bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies.
Reviewed-by: tschatzl, stefank
| author | tschatzl |
|---|---|
| date | Fri, 04 Apr 2014 10:43:56 +0200 |
| parents | 8ee855b4e667 |
| children | 78bbf4d43a14 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
2 * Copyright (c) 2001, 2014, 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:
1550
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1550
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:
1550
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 12080 | 26 #include "code/nmethod.hpp" |
| 1972 | 27 #include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp" |
| 28 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 29 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | |
| 30 #include "gc_implementation/g1/heapRegion.inline.hpp" | |
| 31 #include "gc_implementation/g1/heapRegionRemSet.hpp" | |
| 32 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
| 33 #include "memory/genOopClosures.inline.hpp" | |
| 34 #include "memory/iterator.hpp" | |
| 35 #include "oops/oop.inline.hpp" | |
| 342 | 36 |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
37 int HeapRegion::LogOfHRGrainBytes = 0; |
|
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
38 int HeapRegion::LogOfHRGrainWords = 0; |
|
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
39 size_t HeapRegion::GrainBytes = 0; |
|
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
40 size_t HeapRegion::GrainWords = 0; |
|
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
41 size_t HeapRegion::CardsPerRegion = 0; |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
42 |
| 342 | 43 HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
44 HeapRegion* hr, ExtendedOopClosure* cl, |
| 342 | 45 CardTableModRefBS::PrecisionStyle precision, |
| 46 FilterKind fk) : | |
| 47 ContiguousSpaceDCTOC(hr, cl, precision, NULL), | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
48 _hr(hr), _fk(fk), _g1(g1) { } |
| 342 | 49 |
| 50 FilterOutOfRegionClosure::FilterOutOfRegionClosure(HeapRegion* r, | |
| 51 OopClosure* oc) : | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
52 _r_bottom(r->bottom()), _r_end(r->end()), _oc(oc) { } |
| 342 | 53 |
| 54 template<class ClosureType> | |
| 55 HeapWord* walk_mem_region_loop(ClosureType* cl, G1CollectedHeap* g1h, | |
| 56 HeapRegion* hr, | |
| 57 HeapWord* cur, HeapWord* top) { | |
| 58 oop cur_oop = oop(cur); | |
| 59 int oop_size = cur_oop->size(); | |
| 60 HeapWord* next_obj = cur + oop_size; | |
| 61 while (next_obj < top) { | |
| 62 // Keep filtering the remembered set. | |
| 63 if (!g1h->is_obj_dead(cur_oop, hr)) { | |
| 64 // Bottom lies entirely below top, so we can call the | |
| 65 // non-memRegion version of oop_iterate below. | |
| 66 cur_oop->oop_iterate(cl); | |
| 67 } | |
| 68 cur = next_obj; | |
| 69 cur_oop = oop(cur); | |
| 70 oop_size = cur_oop->size(); | |
| 71 next_obj = cur + oop_size; | |
| 72 } | |
| 73 return cur; | |
| 74 } | |
| 75 | |
| 76 void HeapRegionDCTOC::walk_mem_region_with_cl(MemRegion mr, | |
| 77 HeapWord* bottom, | |
| 78 HeapWord* top, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
79 ExtendedOopClosure* cl) { |
| 342 | 80 G1CollectedHeap* g1h = _g1; |
| 81 int oop_size; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
82 ExtendedOopClosure* cl2 = NULL; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3978
diff
changeset
|
83 |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
84 FilterIntoCSClosure intoCSFilt(this, g1h, cl); |
| 342 | 85 FilterOutOfRegionClosure outOfRegionFilt(_hr, cl); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3978
diff
changeset
|
86 |
| 342 | 87 switch (_fk) { |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
88 case NoFilterKind: cl2 = cl; break; |
| 342 | 89 case IntoCSFilterKind: cl2 = &intoCSFilt; break; |
| 90 case OutOfRegionFilterKind: cl2 = &outOfRegionFilt; break; | |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
91 default: ShouldNotReachHere(); |
| 342 | 92 } |
| 93 | |
| 94 // Start filtering what we add to the remembered set. If the object is | |
| 95 // not considered dead, either because it is marked (in the mark bitmap) | |
| 96 // or it was allocated after marking finished, then we add it. Otherwise | |
| 97 // we can safely ignore the object. | |
| 98 if (!g1h->is_obj_dead(oop(bottom), _hr)) { | |
| 99 oop_size = oop(bottom)->oop_iterate(cl2, mr); | |
| 100 } else { | |
| 101 oop_size = oop(bottom)->size(); | |
| 102 } | |
| 103 | |
| 104 bottom += oop_size; | |
| 105 | |
| 106 if (bottom < top) { | |
| 107 // We replicate the loop below for several kinds of possible filters. | |
| 108 switch (_fk) { | |
| 109 case NoFilterKind: | |
| 110 bottom = walk_mem_region_loop(cl, g1h, _hr, bottom, top); | |
| 111 break; | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3978
diff
changeset
|
112 |
| 342 | 113 case IntoCSFilterKind: { |
|
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
114 FilterIntoCSClosure filt(this, g1h, cl); |
| 342 | 115 bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top); |
| 116 break; | |
| 117 } | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3978
diff
changeset
|
118 |
| 342 | 119 case OutOfRegionFilterKind: { |
| 120 FilterOutOfRegionClosure filt(_hr, cl); | |
| 121 bottom = walk_mem_region_loop(&filt, g1h, _hr, bottom, top); | |
| 122 break; | |
| 123 } | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3978
diff
changeset
|
124 |
| 342 | 125 default: |
| 126 ShouldNotReachHere(); | |
| 127 } | |
| 128 | |
| 129 // Last object. Need to do dead-obj filtering here too. | |
| 130 if (!g1h->is_obj_dead(oop(bottom), _hr)) { | |
| 131 oop(bottom)->oop_iterate(cl2, mr); | |
| 132 } | |
| 133 } | |
| 134 } | |
| 135 | |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
136 // Minimum region size; we won't go lower than that. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
137 // We might want to decrease this in the future, to deal with small |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
138 // heaps a bit more efficiently. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
139 #define MIN_REGION_SIZE ( 1024 * 1024 ) |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
140 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
141 // Maximum region size; we don't go higher than that. There's a good |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
142 // reason for having an upper bound. We don't want regions to get too |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
143 // large, otherwise cleanup's effectiveness would decrease as there |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
144 // will be fewer opportunities to find totally empty regions after |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
145 // marking. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
146 #define MAX_REGION_SIZE ( 32 * 1024 * 1024 ) |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
147 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
148 // The automatic region size calculation will try to have around this |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
149 // many regions in the heap (based on the min heap size). |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
150 #define TARGET_REGION_NUMBER 2048 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
151 |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
152 size_t HeapRegion::max_region_size() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
153 return (size_t)MAX_REGION_SIZE; |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
154 } |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12178
diff
changeset
|
155 |
|
12178
84683e78e713
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
12080
diff
changeset
|
156 void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) { |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
157 uintx region_size = G1HeapRegionSize; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
158 if (FLAG_IS_DEFAULT(G1HeapRegionSize)) { |
|
12178
84683e78e713
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
12080
diff
changeset
|
159 size_t average_heap_size = (initial_heap_size + max_heap_size) / 2; |
|
84683e78e713
8019902: G1: Use the average heap size rather than the minimum heap size to calculate the region size
brutisso
parents:
12080
diff
changeset
|
160 region_size = MAX2(average_heap_size / TARGET_REGION_NUMBER, |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
161 (uintx) MIN_REGION_SIZE); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
162 } |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
163 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
164 int region_size_log = log2_long((jlong) region_size); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
165 // Recalculate the region size to make sure it's a power of |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
166 // 2. This means that region_size is the largest power of 2 that's |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
167 // <= what we've calculated so far. |
|
1485
fb57d4cf76c2
6931180: Migration to recent versions of MS Platform SDK
prr
parents:
1394
diff
changeset
|
168 region_size = ((uintx)1 << region_size_log); |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
169 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
170 // Now make sure that we don't go over or under our limits. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
171 if (region_size < MIN_REGION_SIZE) { |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
172 region_size = MIN_REGION_SIZE; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
173 } else if (region_size > MAX_REGION_SIZE) { |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
174 region_size = MAX_REGION_SIZE; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
175 } |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
176 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
177 // And recalculate the log. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
178 region_size_log = log2_long((jlong) region_size); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
179 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
180 // Now, set up the globals. |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
181 guarantee(LogOfHRGrainBytes == 0, "we should only set it once"); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
182 LogOfHRGrainBytes = region_size_log; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
183 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
184 guarantee(LogOfHRGrainWords == 0, "we should only set it once"); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
185 LogOfHRGrainWords = LogOfHRGrainBytes - LogHeapWordSize; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
186 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
187 guarantee(GrainBytes == 0, "we should only set it once"); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
188 // The cast to int is safe, given that we've bounded region_size by |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
189 // MIN_REGION_SIZE and MAX_REGION_SIZE. |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
190 GrainBytes = (size_t)region_size; |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
191 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
192 guarantee(GrainWords == 0, "we should only set it once"); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
193 GrainWords = GrainBytes >> LogHeapWordSize; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
194 guarantee((size_t) 1 << LogOfHRGrainWords == GrainWords, "sanity"); |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
195 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
196 guarantee(CardsPerRegion == 0, "we should only set it once"); |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
197 CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
198 } |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
866
diff
changeset
|
199 |
| 342 | 200 void HeapRegion::reset_after_compaction() { |
| 201 G1OffsetTableContigSpace::reset_after_compaction(); | |
| 202 // After a compaction the mark bitmap is invalid, so we must | |
| 203 // treat all objects as being inside the unmarked area. | |
| 204 zero_marked_bytes(); | |
| 205 init_top_at_mark_start(); | |
| 206 } | |
| 207 | |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
208 void HeapRegion::hr_clear(bool par, bool clear_space, bool locked) { |
| 2152 | 209 assert(_humongous_type == NotHumongous, |
| 210 "we should have already filtered out humongous regions"); | |
| 211 assert(_humongous_start_region == NULL, | |
| 212 "we should have already filtered out humongous regions"); | |
| 213 assert(_end == _orig_end, | |
| 214 "we should have already filtered out humongous regions"); | |
| 215 | |
| 342 | 216 _in_collection_set = false; |
| 217 | |
| 218 set_young_index_in_cset(-1); | |
| 219 uninstall_surv_rate_group(); | |
| 220 set_young_type(NotYoung); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2152
diff
changeset
|
221 reset_pre_dummy_top(); |
| 342 | 222 |
| 223 if (!par) { | |
| 224 // If this is parallel, this will be done later. | |
| 225 HeapRegionRemSet* hrrs = rem_set(); | |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
226 if (locked) { |
|
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
227 hrrs->clear_locked(); |
|
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
228 } else { |
|
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
229 hrrs->clear(); |
|
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
230 } |
| 355 | 231 _claimed = InitialClaimValue; |
| 342 | 232 } |
| 233 zero_marked_bytes(); | |
| 234 | |
| 235 _offsets.resize(HeapRegion::GrainWords); | |
| 236 init_top_at_mark_start(); | |
| 356 | 237 if (clear_space) clear(SpaceDecorator::Mangle); |
| 342 | 238 } |
| 239 | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
240 void HeapRegion::par_clear() { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
241 assert(used() == 0, "the region should have been already cleared"); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
242 assert(capacity() == HeapRegion::GrainBytes, "should be back to normal"); |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
243 HeapRegionRemSet* hrrs = rem_set(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
244 hrrs->clear(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
245 CardTableModRefBS* ct_bs = |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
246 (CardTableModRefBS*)G1CollectedHeap::heap()->barrier_set(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
247 ct_bs->clear(MemRegion(bottom(), end())); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
248 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
249 |
| 342 | 250 void HeapRegion::calc_gc_efficiency() { |
| 6611 | 251 // GC efficiency is the ratio of how much space would be |
| 252 // reclaimed over how long we predict it would take to reclaim it. | |
| 342 | 253 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4839
diff
changeset
|
254 G1CollectorPolicy* g1p = g1h->g1_policy(); |
| 6611 | 255 |
| 256 // Retrieve a prediction of the elapsed time for this region for | |
| 257 // a mixed gc because the region will only be evacuated during a | |
| 258 // mixed gc. | |
| 259 double region_elapsed_time_ms = | |
| 260 g1p->predict_region_elapsed_time_ms(this, false /* for_young_gc */); | |
| 261 _gc_efficiency = (double) reclaimable_bytes() / region_elapsed_time_ms; | |
| 342 | 262 } |
| 263 | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
264 void HeapRegion::set_startsHumongous(HeapWord* new_top, HeapWord* new_end) { |
| 2152 | 265 assert(!isHumongous(), "sanity / pre-condition"); |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
266 assert(end() == _orig_end, |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
267 "Should be normal before the humongous object allocation"); |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
268 assert(top() == bottom(), "should be empty"); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
269 assert(bottom() <= new_top && new_top <= new_end, "pre-condition"); |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
270 |
| 355 | 271 _humongous_type = StartsHumongous; |
| 342 | 272 _humongous_start_region = this; |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
273 |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
274 set_end(new_end); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
275 _offsets.set_for_starts_humongous(new_top); |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
276 } |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
277 |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
278 void HeapRegion::set_continuesHumongous(HeapRegion* first_hr) { |
| 2152 | 279 assert(!isHumongous(), "sanity / pre-condition"); |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
280 assert(end() == _orig_end, |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
281 "Should be normal before the humongous object allocation"); |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
282 assert(top() == bottom(), "should be empty"); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
283 assert(first_hr->startsHumongous(), "pre-condition"); |
|
1886
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
284 |
|
72a161e62cc4
6991377: G1: race between concurrent refinement and humongous object allocation
tonyp
parents:
1718
diff
changeset
|
285 _humongous_type = ContinuesHumongous; |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
286 _humongous_start_region = first_hr; |
| 342 | 287 } |
| 288 | |
| 2152 | 289 void HeapRegion::set_notHumongous() { |
| 290 assert(isHumongous(), "pre-condition"); | |
| 291 | |
| 292 if (startsHumongous()) { | |
| 293 assert(top() <= end(), "pre-condition"); | |
| 294 set_end(_orig_end); | |
| 295 if (top() > end()) { | |
| 296 // at least one "continues humongous" region after it | |
| 297 set_top(end()); | |
| 298 } | |
| 299 } else { | |
| 300 // continues humongous | |
| 301 assert(end() == _orig_end, "sanity"); | |
| 302 } | |
| 303 | |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
304 assert(capacity() == HeapRegion::GrainBytes, "pre-condition"); |
| 2152 | 305 _humongous_type = NotHumongous; |
| 306 _humongous_start_region = NULL; | |
| 307 } | |
| 308 | |
| 342 | 309 bool HeapRegion::claimHeapRegion(jint claimValue) { |
| 310 jint current = _claimed; | |
| 311 if (current != claimValue) { | |
| 312 jint res = Atomic::cmpxchg(claimValue, &_claimed, current); | |
| 313 if (res == current) { | |
| 314 return true; | |
| 315 } | |
| 316 } | |
| 317 return false; | |
| 318 } | |
| 319 | |
| 320 HeapWord* HeapRegion::next_block_start_careful(HeapWord* addr) { | |
| 321 HeapWord* low = addr; | |
| 322 HeapWord* high = end(); | |
| 323 while (low < high) { | |
| 324 size_t diff = pointer_delta(high, low); | |
| 325 // Must add one below to bias toward the high amount. Otherwise, if | |
| 326 // "high" were at the desired value, and "low" were one less, we | |
| 327 // would not converge on "high". This is not symmetric, because | |
| 328 // we set "high" to a block start, which might be the right one, | |
| 329 // which we don't do for "low". | |
| 330 HeapWord* middle = low + (diff+1)/2; | |
| 331 if (middle == high) return high; | |
| 332 HeapWord* mid_bs = block_start_careful(middle); | |
| 333 if (mid_bs < addr) { | |
| 334 low = middle; | |
| 335 } else { | |
| 336 high = mid_bs; | |
| 337 } | |
| 338 } | |
| 339 assert(low == high && low >= addr, "Didn't work."); | |
| 340 return low; | |
| 341 } | |
| 342 | |
| 343 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away | |
| 344 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 345 #endif // _MSC_VER | |
| 346 | |
| 347 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
348 HeapRegion::HeapRegion(uint hrs_index, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
349 G1BlockOffsetSharedArray* sharedOffsetArray, |
|
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
350 MemRegion mr) : |
|
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
351 G1OffsetTableContigSpace(sharedOffsetArray, mr), |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3978
diff
changeset
|
352 _hrs_index(hrs_index), |
| 355 | 353 _humongous_type(NotHumongous), _humongous_start_region(NULL), |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3772
diff
changeset
|
354 _in_collection_set(false), |
| 342 | 355 _next_in_special_set(NULL), _orig_end(NULL), |
| 355 | 356 _claimed(InitialClaimValue), _evacuation_failed(false), |
| 6011 | 357 _prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0), |
| 342 | 358 _young_type(NotYoung), _next_young_region(NULL), |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17755
diff
changeset
|
359 _next_dirty_cards_region(NULL), _next(NULL), _prev(NULL), _pending_removal(false), |
| 2152 | 360 #ifdef ASSERT |
| 361 _containing_set(NULL), | |
| 362 #endif // ASSERT | |
| 363 _young_index_in_cset(-1), _surv_rate_group(NULL), _age_index(-1), | |
| 364 _rem_set(NULL), _recorded_rs_length(0), _predicted_elapsed_time_ms(0), | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1388
diff
changeset
|
365 _predicted_bytes_to_copy(0) |
| 342 | 366 { |
| 12080 | 367 _rem_set = new HeapRegionRemSet(sharedOffsetArray, this); |
| 342 | 368 _orig_end = mr.end(); |
| 369 // Note that initialize() will set the start of the unmarked area of the | |
| 370 // region. | |
|
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
371 hr_clear(false /*par*/, false /*clear_space*/); |
| 356 | 372 set_top(bottom()); |
| 373 set_saved_mark(); | |
| 342 | 374 |
| 375 assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant."); | |
| 376 } | |
| 377 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
378 CompactibleSpace* HeapRegion::next_compaction_space() const { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
379 // We're not using an iterator given that it will wrap around when |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
380 // it reaches the last region and this is not what we want here. |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
381 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
382 uint index = hrs_index() + 1; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
383 while (index < g1h->n_regions()) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
384 HeapRegion* hr = g1h->region_at(index); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
385 if (!hr->isHumongous()) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
386 return hr; |
| 342 | 387 } |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
388 index += 1; |
| 342 | 389 } |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6027
diff
changeset
|
390 return NULL; |
| 342 | 391 } |
| 392 | |
| 393 void HeapRegion::save_marks() { | |
| 394 set_saved_mark(); | |
| 395 } | |
| 396 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
397 void HeapRegion::oops_in_mr_iterate(MemRegion mr, ExtendedOopClosure* cl) { |
| 342 | 398 HeapWord* p = mr.start(); |
| 399 HeapWord* e = mr.end(); | |
| 400 oop obj; | |
| 401 while (p < e) { | |
| 402 obj = oop(p); | |
| 403 p += obj->oop_iterate(cl); | |
| 404 } | |
| 405 assert(p == e, "bad memregion: doesn't end on obj boundary"); | |
| 406 } | |
| 407 | |
| 408 #define HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \ | |
| 409 void HeapRegion::oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \ | |
| 410 ContiguousSpace::oop_since_save_marks_iterate##nv_suffix(cl); \ | |
| 411 } | |
| 412 SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN) | |
| 413 | |
| 414 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
415 void HeapRegion::oop_before_save_marks_iterate(ExtendedOopClosure* cl) { |
| 342 | 416 oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl); |
| 417 } | |
| 418 | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
419 void HeapRegion::note_self_forwarding_removal_start(bool during_initial_mark, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
420 bool during_conc_mark) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
421 // We always recreate the prev marking info and we'll explicitly |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
422 // mark all objects we find to be self-forwarded on the prev |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
423 // bitmap. So all objects need to be below PTAMS. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
424 _prev_top_at_mark_start = top(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
425 _prev_marked_bytes = 0; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
426 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
427 if (during_initial_mark) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
428 // During initial-mark, we'll also explicitly mark all objects |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
429 // we find to be self-forwarded on the next bitmap. So all |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
430 // objects need to be below NTAMS. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
431 _next_top_at_mark_start = top(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
432 _next_marked_bytes = 0; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
433 } else if (during_conc_mark) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
434 // During concurrent mark, all objects in the CSet (including |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
435 // the ones we find to be self-forwarded) are implicitly live. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
436 // So all objects need to be above NTAMS. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
437 _next_top_at_mark_start = bottom(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
438 _next_marked_bytes = 0; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
439 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
440 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
441 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
442 void HeapRegion::note_self_forwarding_removal_end(bool during_initial_mark, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
443 bool during_conc_mark, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
444 size_t marked_bytes) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
445 assert(0 <= marked_bytes && marked_bytes <= used(), |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
446 err_msg("marked: "SIZE_FORMAT" used: "SIZE_FORMAT, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
447 marked_bytes, used())); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
448 _prev_marked_bytes = marked_bytes; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
449 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4725
diff
changeset
|
450 |
| 342 | 451 HeapWord* |
| 452 HeapRegion::object_iterate_mem_careful(MemRegion mr, | |
| 453 ObjectClosure* cl) { | |
| 454 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 455 // We used to use "block_start_careful" here. But we're actually happy | |
| 456 // to update the BOT while we do this... | |
| 457 HeapWord* cur = block_start(mr.start()); | |
| 458 mr = mr.intersection(used_region()); | |
| 459 if (mr.is_empty()) return NULL; | |
| 460 // Otherwise, find the obj that extends onto mr.start(). | |
| 461 | |
| 462 assert(cur <= mr.start() | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
463 && (oop(cur)->klass_or_null() == NULL || |
| 342 | 464 cur + oop(cur)->size() > mr.start()), |
| 465 "postcondition of block_start"); | |
| 466 oop obj; | |
| 467 while (cur < mr.end()) { | |
| 468 obj = oop(cur); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
469 if (obj->klass_or_null() == NULL) { |
| 342 | 470 // Ran into an unparseable point. |
| 471 return cur; | |
| 472 } else if (!g1h->is_obj_dead(obj)) { | |
| 473 cl->do_object(obj); | |
| 474 } | |
| 475 if (cl->abort()) return cur; | |
| 476 // The check above must occur before the operation below, since an | |
| 477 // abort might invalidate the "size" operation. | |
| 478 cur += obj->size(); | |
| 479 } | |
| 480 return NULL; | |
| 481 } | |
| 482 | |
| 483 HeapWord* | |
| 484 HeapRegion:: | |
| 485 oops_on_card_seq_iterate_careful(MemRegion mr, | |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
486 FilterOutOfRegionClosure* cl, |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
487 bool filter_young, |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
488 jbyte* card_ptr) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
489 // Currently, we should only have to clean the card if filter_young |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
490 // is true and vice versa. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
491 if (filter_young) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
492 assert(card_ptr != NULL, "pre-condition"); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
493 } else { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
494 assert(card_ptr == NULL, "pre-condition"); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
495 } |
| 342 | 496 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
| 497 | |
| 498 // If we're within a stop-world GC, then we might look at a card in a | |
| 499 // GC alloc region that extends onto a GC LAB, which may not be | |
| 500 // parseable. Stop such at the "saved_mark" of the region. | |
| 4839 | 501 if (g1h->is_gc_active()) { |
| 342 | 502 mr = mr.intersection(used_region_at_save_marks()); |
| 503 } else { | |
| 504 mr = mr.intersection(used_region()); | |
| 505 } | |
| 506 if (mr.is_empty()) return NULL; | |
| 507 // Otherwise, find the obj that extends onto mr.start(). | |
| 508 | |
|
1666
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
509 // The intersection of the incoming mr (for the card) and the |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
510 // allocated part of the region is non-empty. This implies that |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
511 // we have actually allocated into this region. The code in |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
512 // G1CollectedHeap.cpp that allocates a new region sets the |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
513 // is_young tag on the region before allocating. Thus we |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
514 // safely know if this region is young. |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
515 if (is_young() && filter_young) { |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
516 return NULL; |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
517 } |
|
5cbac8938c4c
6956639: G1: assert(cached_ptr != card_ptr) failed: shouldn't be, concurrentG1Refine.cpp:307
johnc
parents:
1552
diff
changeset
|
518 |
| 1705 | 519 assert(!is_young(), "check value of filter_young"); |
| 520 | |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
521 // We can only clean the card here, after we make the decision that |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
522 // the card is not young. And we only clean the card if we have been |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
523 // asked to (i.e., card_ptr != NULL). |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
524 if (card_ptr != NULL) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
525 *card_ptr = CardTableModRefBS::clean_card_val(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
526 // We must complete this write before we do any of the reads below. |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
527 OrderAccess::storeload(); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
528 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
2433
diff
changeset
|
529 |
| 4839 | 530 // Cache the boundaries of the memory region in some const locals |
| 531 HeapWord* const start = mr.start(); | |
| 532 HeapWord* const end = mr.end(); | |
| 533 | |
| 342 | 534 // We used to use "block_start_careful" here. But we're actually happy |
| 535 // to update the BOT while we do this... | |
| 4839 | 536 HeapWord* cur = block_start(start); |
| 537 assert(cur <= start, "Postcondition"); | |
| 538 | |
| 539 oop obj; | |
| 342 | 540 |
| 4839 | 541 HeapWord* next = cur; |
| 542 while (next <= start) { | |
| 543 cur = next; | |
| 544 obj = oop(cur); | |
| 545 if (obj->klass_or_null() == NULL) { | |
| 342 | 546 // Ran into an unparseable point. |
| 547 return cur; | |
| 548 } | |
| 549 // Otherwise... | |
| 4839 | 550 next = (cur + obj->size()); |
| 342 | 551 } |
| 4839 | 552 |
| 553 // If we finish the above loop...We have a parseable object that | |
| 554 // begins on or before the start of the memory region, and ends | |
| 555 // inside or spans the entire region. | |
| 556 | |
| 557 assert(obj == oop(cur), "sanity"); | |
| 558 assert(cur <= start && | |
| 559 obj->klass_or_null() != NULL && | |
| 560 (cur + obj->size()) > start, | |
| 342 | 561 "Loop postcondition"); |
| 4839 | 562 |
| 342 | 563 if (!g1h->is_obj_dead(obj)) { |
| 564 obj->oop_iterate(cl, mr); | |
| 565 } | |
| 566 | |
| 4839 | 567 while (cur < end) { |
| 342 | 568 obj = oop(cur); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
569 if (obj->klass_or_null() == NULL) { |
| 342 | 570 // Ran into an unparseable point. |
| 571 return cur; | |
| 572 }; | |
| 4839 | 573 |
| 342 | 574 // Otherwise: |
| 575 next = (cur + obj->size()); | |
| 4839 | 576 |
| 342 | 577 if (!g1h->is_obj_dead(obj)) { |
| 4839 | 578 if (next < end || !obj->is_objArray()) { |
| 579 // This object either does not span the MemRegion | |
| 580 // boundary, or if it does it's not an array. | |
| 581 // Apply closure to whole object. | |
| 342 | 582 obj->oop_iterate(cl); |
| 583 } else { | |
| 4839 | 584 // This obj is an array that spans the boundary. |
| 585 // Stop at the boundary. | |
| 586 obj->oop_iterate(cl, mr); | |
| 342 | 587 } |
| 588 } | |
| 589 cur = next; | |
| 590 } | |
| 591 return NULL; | |
| 592 } | |
| 593 | |
| 12080 | 594 // Code roots support |
| 595 | |
| 596 void HeapRegion::add_strong_code_root(nmethod* nm) { | |
| 597 HeapRegionRemSet* hrrs = rem_set(); | |
| 598 hrrs->add_strong_code_root(nm); | |
| 599 } | |
| 600 | |
| 601 void HeapRegion::remove_strong_code_root(nmethod* nm) { | |
| 602 HeapRegionRemSet* hrrs = rem_set(); | |
| 603 hrrs->remove_strong_code_root(nm); | |
| 604 } | |
| 605 | |
| 606 void HeapRegion::migrate_strong_code_roots() { | |
| 607 assert(in_collection_set(), "only collection set regions"); | |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
608 assert(!isHumongous(), |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
609 err_msg("humongous region "HR_FORMAT" should not have been added to collection set", |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
610 HR_FORMAT_PARAMS(this))); |
| 12080 | 611 |
| 612 HeapRegionRemSet* hrrs = rem_set(); | |
| 613 hrrs->migrate_strong_code_roots(); | |
| 614 } | |
| 615 | |
| 616 void HeapRegion::strong_code_roots_do(CodeBlobClosure* blk) const { | |
| 617 HeapRegionRemSet* hrrs = rem_set(); | |
| 618 hrrs->strong_code_roots_do(blk); | |
| 619 } | |
| 620 | |
| 621 class VerifyStrongCodeRootOopClosure: public OopClosure { | |
| 622 const HeapRegion* _hr; | |
| 623 nmethod* _nm; | |
| 624 bool _failures; | |
| 625 bool _has_oops_in_region; | |
| 626 | |
| 627 template <class T> void do_oop_work(T* p) { | |
| 628 T heap_oop = oopDesc::load_heap_oop(p); | |
| 629 if (!oopDesc::is_null(heap_oop)) { | |
| 630 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 631 | |
| 632 // Note: not all the oops embedded in the nmethod are in the | |
| 633 // current region. We only look at those which are. | |
| 634 if (_hr->is_in(obj)) { | |
| 635 // Object is in the region. Check that its less than top | |
| 636 if (_hr->top() <= (HeapWord*)obj) { | |
| 637 // Object is above top | |
| 638 gclog_or_tty->print_cr("Object "PTR_FORMAT" in region " | |
| 639 "["PTR_FORMAT", "PTR_FORMAT") is above " | |
| 640 "top "PTR_FORMAT, | |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
12233
diff
changeset
|
641 (void *)obj, _hr->bottom(), _hr->end(), _hr->top()); |
| 12080 | 642 _failures = true; |
| 643 return; | |
| 644 } | |
| 645 // Nmethod has at least one oop in the current region | |
| 646 _has_oops_in_region = true; | |
| 647 } | |
| 648 } | |
| 649 } | |
| 650 | |
| 651 public: | |
| 652 VerifyStrongCodeRootOopClosure(const HeapRegion* hr, nmethod* nm): | |
| 653 _hr(hr), _failures(false), _has_oops_in_region(false) {} | |
| 654 | |
| 655 void do_oop(narrowOop* p) { do_oop_work(p); } | |
| 656 void do_oop(oop* p) { do_oop_work(p); } | |
| 657 | |
| 658 bool failures() { return _failures; } | |
| 659 bool has_oops_in_region() { return _has_oops_in_region; } | |
| 660 }; | |
| 661 | |
| 662 class VerifyStrongCodeRootCodeBlobClosure: public CodeBlobClosure { | |
| 663 const HeapRegion* _hr; | |
| 664 bool _failures; | |
| 665 public: | |
| 666 VerifyStrongCodeRootCodeBlobClosure(const HeapRegion* hr) : | |
| 667 _hr(hr), _failures(false) {} | |
| 668 | |
| 669 void do_code_blob(CodeBlob* cb) { | |
| 670 nmethod* nm = (cb == NULL) ? NULL : cb->as_nmethod_or_null(); | |
| 671 if (nm != NULL) { | |
| 672 // Verify that the nemthod is live | |
| 673 if (!nm->is_alive()) { | |
| 674 gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has dead nmethod " | |
| 675 PTR_FORMAT" in its strong code roots", | |
| 676 _hr->bottom(), _hr->end(), nm); | |
| 677 _failures = true; | |
| 678 } else { | |
| 679 VerifyStrongCodeRootOopClosure oop_cl(_hr, nm); | |
| 680 nm->oops_do(&oop_cl); | |
| 681 if (!oop_cl.has_oops_in_region()) { | |
| 682 gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has nmethod " | |
| 683 PTR_FORMAT" in its strong code roots " | |
| 684 "with no pointers into region", | |
| 685 _hr->bottom(), _hr->end(), nm); | |
| 686 _failures = true; | |
| 687 } else if (oop_cl.failures()) { | |
| 688 gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has other " | |
| 689 "failures for nmethod "PTR_FORMAT, | |
| 690 _hr->bottom(), _hr->end(), nm); | |
| 691 _failures = true; | |
| 692 } | |
| 693 } | |
| 694 } | |
| 695 } | |
| 696 | |
| 697 bool failures() { return _failures; } | |
| 698 }; | |
| 699 | |
| 700 void HeapRegion::verify_strong_code_roots(VerifyOption vo, bool* failures) const { | |
| 701 if (!G1VerifyHeapRegionCodeRoots) { | |
| 702 // We're not verifying code roots. | |
| 703 return; | |
| 704 } | |
| 705 if (vo == VerifyOption_G1UseMarkWord) { | |
| 706 // Marking verification during a full GC is performed after class | |
| 707 // unloading, code cache unloading, etc so the strong code roots | |
| 708 // attached to each heap region are in an inconsistent state. They won't | |
| 709 // be consistent until the strong code roots are rebuilt after the | |
| 710 // actual GC. Skip verifying the strong code roots in this particular | |
| 711 // time. | |
| 712 assert(VerifyDuringGC, "only way to get here"); | |
| 713 return; | |
| 714 } | |
| 715 | |
| 716 HeapRegionRemSet* hrrs = rem_set(); | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
13062
diff
changeset
|
717 size_t strong_code_roots_length = hrrs->strong_code_roots_list_length(); |
| 12080 | 718 |
| 719 // if this region is empty then there should be no entries | |
| 720 // on its strong code root list | |
| 721 if (is_empty()) { | |
| 722 if (strong_code_roots_length > 0) { | |
| 723 gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is empty " | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
13062
diff
changeset
|
724 "but has "SIZE_FORMAT" code root entries", |
| 12080 | 725 bottom(), end(), strong_code_roots_length); |
| 726 *failures = true; | |
| 727 } | |
| 728 return; | |
| 729 } | |
| 730 | |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
731 if (continuesHumongous()) { |
| 12080 | 732 if (strong_code_roots_length > 0) { |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
733 gclog_or_tty->print_cr("region "HR_FORMAT" is a continuation of a humongous " |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
13062
diff
changeset
|
734 "region but has "SIZE_FORMAT" code root entries", |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
735 HR_FORMAT_PARAMS(this), strong_code_roots_length); |
| 12080 | 736 *failures = true; |
| 737 } | |
| 738 return; | |
| 739 } | |
| 740 | |
| 741 VerifyStrongCodeRootCodeBlobClosure cb_cl(this); | |
| 742 strong_code_roots_do(&cb_cl); | |
| 743 | |
| 744 if (cb_cl.failures()) { | |
| 745 *failures = true; | |
| 746 } | |
| 747 } | |
| 748 | |
| 342 | 749 void HeapRegion::print() const { print_on(gclog_or_tty); } |
| 750 void HeapRegion::print_on(outputStream* st) const { | |
| 751 if (isHumongous()) { | |
| 752 if (startsHumongous()) | |
| 753 st->print(" HS"); | |
| 754 else | |
| 755 st->print(" HC"); | |
| 756 } else { | |
| 757 st->print(" "); | |
| 758 } | |
| 759 if (in_collection_set()) | |
| 760 st->print(" CS"); | |
| 761 else | |
| 762 st->print(" "); | |
| 763 if (is_young()) | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1388
diff
changeset
|
764 st->print(is_survivor() ? " SU" : " Y "); |
| 342 | 765 else |
| 766 st->print(" "); | |
| 767 if (is_empty()) | |
| 768 st->print(" F"); | |
| 769 else | |
| 770 st->print(" "); | |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4023
diff
changeset
|
771 st->print(" TS %5d", _gc_time_stamp); |
| 1388 | 772 st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT, |
| 773 prev_top_at_mark_start(), next_top_at_mark_start()); | |
| 342 | 774 G1OffsetTableContigSpace::print_on(st); |
| 775 } | |
| 776 | |
| 12080 | 777 class VerifyLiveClosure: public OopClosure { |
| 778 private: | |
| 779 G1CollectedHeap* _g1h; | |
| 780 CardTableModRefBS* _bs; | |
| 781 oop _containing_obj; | |
| 782 bool _failures; | |
| 783 int _n_failures; | |
| 784 VerifyOption _vo; | |
| 785 public: | |
| 786 // _vo == UsePrevMarking -> use "prev" marking information, | |
| 787 // _vo == UseNextMarking -> use "next" marking information, | |
| 788 // _vo == UseMarkWord -> use mark word from object header. | |
| 789 VerifyLiveClosure(G1CollectedHeap* g1h, VerifyOption vo) : | |
| 790 _g1h(g1h), _bs(NULL), _containing_obj(NULL), | |
| 791 _failures(false), _n_failures(0), _vo(vo) | |
| 792 { | |
| 793 BarrierSet* bs = _g1h->barrier_set(); | |
| 794 if (bs->is_a(BarrierSet::CardTableModRef)) | |
| 795 _bs = (CardTableModRefBS*)bs; | |
| 796 } | |
| 797 | |
| 798 void set_containing_obj(oop obj) { | |
| 799 _containing_obj = obj; | |
| 800 } | |
| 801 | |
| 802 bool failures() { return _failures; } | |
| 803 int n_failures() { return _n_failures; } | |
| 804 | |
| 805 virtual void do_oop(narrowOop* p) { do_oop_work(p); } | |
| 806 virtual void do_oop( oop* p) { do_oop_work(p); } | |
| 807 | |
| 808 void print_object(outputStream* out, oop obj) { | |
| 809 #ifdef PRODUCT | |
| 810 Klass* k = obj->klass(); | |
| 811 const char* class_name = InstanceKlass::cast(k)->external_name(); | |
| 812 out->print_cr("class name %s", class_name); | |
| 813 #else // PRODUCT | |
| 814 obj->print_on(out); | |
| 815 #endif // PRODUCT | |
| 816 } | |
| 817 | |
| 818 template <class T> | |
| 819 void do_oop_work(T* p) { | |
| 820 assert(_containing_obj != NULL, "Precondition"); | |
| 821 assert(!_g1h->is_obj_dead_cond(_containing_obj, _vo), | |
| 822 "Precondition"); | |
| 823 T heap_oop = oopDesc::load_heap_oop(p); | |
| 824 if (!oopDesc::is_null(heap_oop)) { | |
| 825 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 826 bool failed = false; | |
| 827 if (!_g1h->is_in_closed_subset(obj) || _g1h->is_obj_dead_cond(obj, _vo)) { | |
| 828 MutexLockerEx x(ParGCRareEvent_lock, | |
| 829 Mutex::_no_safepoint_check_flag); | |
| 830 | |
| 831 if (!_failures) { | |
| 832 gclog_or_tty->print_cr(""); | |
| 833 gclog_or_tty->print_cr("----------"); | |
| 834 } | |
| 835 if (!_g1h->is_in_closed_subset(obj)) { | |
| 836 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); | |
| 837 gclog_or_tty->print_cr("Field "PTR_FORMAT | |
| 838 " of live obj "PTR_FORMAT" in region " | |
| 839 "["PTR_FORMAT", "PTR_FORMAT")", | |
| 840 p, (void*) _containing_obj, | |
| 841 from->bottom(), from->end()); | |
| 842 print_object(gclog_or_tty, _containing_obj); | |
| 843 gclog_or_tty->print_cr("points to obj "PTR_FORMAT" not in the heap", | |
| 844 (void*) obj); | |
| 845 } else { | |
| 846 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); | |
| 847 HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj); | |
| 848 gclog_or_tty->print_cr("Field "PTR_FORMAT | |
| 849 " of live obj "PTR_FORMAT" in region " | |
| 850 "["PTR_FORMAT", "PTR_FORMAT")", | |
| 851 p, (void*) _containing_obj, | |
| 852 from->bottom(), from->end()); | |
| 853 print_object(gclog_or_tty, _containing_obj); | |
| 854 gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region " | |
| 855 "["PTR_FORMAT", "PTR_FORMAT")", | |
| 856 (void*) obj, to->bottom(), to->end()); | |
| 857 print_object(gclog_or_tty, obj); | |
| 858 } | |
| 859 gclog_or_tty->print_cr("----------"); | |
| 860 gclog_or_tty->flush(); | |
| 861 _failures = true; | |
| 862 failed = true; | |
| 863 _n_failures++; | |
| 864 } | |
| 865 | |
| 866 if (!_g1h->full_collection() || G1VerifyRSetsDuringFullGC) { | |
| 867 HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); | |
| 868 HeapRegion* to = _g1h->heap_region_containing(obj); | |
| 869 if (from != NULL && to != NULL && | |
| 870 from != to && | |
| 871 !to->isHumongous()) { | |
| 872 jbyte cv_obj = *_bs->byte_for_const(_containing_obj); | |
| 873 jbyte cv_field = *_bs->byte_for_const(p); | |
| 874 const jbyte dirty = CardTableModRefBS::dirty_card_val(); | |
| 875 | |
| 876 bool is_bad = !(from->is_young() | |
| 877 || to->rem_set()->contains_reference(p) | |
| 878 || !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed | |
| 879 (_containing_obj->is_objArray() ? | |
| 880 cv_field == dirty | |
| 881 : cv_obj == dirty || cv_field == dirty)); | |
| 882 if (is_bad) { | |
| 883 MutexLockerEx x(ParGCRareEvent_lock, | |
| 884 Mutex::_no_safepoint_check_flag); | |
| 885 | |
| 886 if (!_failures) { | |
| 887 gclog_or_tty->print_cr(""); | |
| 888 gclog_or_tty->print_cr("----------"); | |
| 889 } | |
| 890 gclog_or_tty->print_cr("Missing rem set entry:"); | |
| 891 gclog_or_tty->print_cr("Field "PTR_FORMAT" " | |
| 892 "of obj "PTR_FORMAT", " | |
| 893 "in region "HR_FORMAT, | |
| 894 p, (void*) _containing_obj, | |
| 895 HR_FORMAT_PARAMS(from)); | |
| 896 _containing_obj->print_on(gclog_or_tty); | |
| 897 gclog_or_tty->print_cr("points to obj "PTR_FORMAT" " | |
| 898 "in region "HR_FORMAT, | |
| 899 (void*) obj, | |
| 900 HR_FORMAT_PARAMS(to)); | |
| 901 obj->print_on(gclog_or_tty); | |
| 902 gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.", | |
| 903 cv_obj, cv_field); | |
| 904 gclog_or_tty->print_cr("----------"); | |
| 905 gclog_or_tty->flush(); | |
| 906 _failures = true; | |
| 907 if (!failed) _n_failures++; | |
| 908 } | |
| 909 } | |
| 910 } | |
| 911 } | |
| 912 } | |
| 913 }; | |
| 811 | 914 |
| 342 | 915 // This really ought to be commoned up into OffsetTableContigSpace somehow. |
| 916 // We would need a mechanism to make that code skip dead objects. | |
| 917 | |
| 6008 | 918 void HeapRegion::verify(VerifyOption vo, |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
919 bool* failures) const { |
| 342 | 920 G1CollectedHeap* g1 = G1CollectedHeap::heap(); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
921 *failures = false; |
| 342 | 922 HeapWord* p = bottom(); |
| 923 HeapWord* prev_p = NULL; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
924 VerifyLiveClosure vl_cl(g1, vo); |
|
1718
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
925 bool is_humongous = isHumongous(); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
926 bool do_bot_verify = !is_young(); |
|
1718
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
927 size_t object_num = 0; |
| 342 | 928 while (p < top()) { |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
929 oop obj = oop(p); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
930 size_t obj_size = obj->size(); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
931 object_num += 1; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
932 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
933 if (is_humongous != g1->isHumongous(obj_size)) { |
|
1718
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
934 gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size (" |
|
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
935 SIZE_FORMAT" words) in a %shumongous region", |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
936 p, g1->isHumongous(obj_size) ? "" : "non-", |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
937 obj_size, is_humongous ? "" : "non-"); |
|
1718
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
938 *failures = true; |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
939 return; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
940 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
941 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
942 // If it returns false, verify_for_object() will output the |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
943 // appropriate messasge. |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
944 if (do_bot_verify && !_offsets.verify_for_object(p, obj_size)) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
945 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
946 return; |
|
1718
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
947 } |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
948 |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
949 if (!g1->is_obj_dead_cond(obj, this, vo)) { |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
950 if (obj->is_oop()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
951 Klass* klass = obj->klass(); |
| 11034 | 952 if (!klass->is_metaspace_object()) { |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
953 gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
12233
diff
changeset
|
954 "not metadata", klass, (void *)obj); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
955 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
956 return; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
957 } else if (!klass->is_klass()) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
958 gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
12233
diff
changeset
|
959 "not a klass", klass, (void *)obj); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
960 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
961 return; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
962 } else { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
963 vl_cl.set_containing_obj(obj); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6611
diff
changeset
|
964 obj->oop_iterate_no_header(&vl_cl); |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
965 if (vl_cl.failures()) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
966 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
967 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
968 if (G1MaxVerifyFailures >= 0 && |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
969 vl_cl.n_failures() >= G1MaxVerifyFailures) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
970 return; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
971 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
972 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
973 } else { |
|
12316
190899198332
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
12233
diff
changeset
|
974 gclog_or_tty->print_cr(PTR_FORMAT" no an oop", (void *)obj); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
975 *failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
976 return; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
977 } |
| 342 | 978 } |
| 979 prev_p = p; | |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
980 p += obj_size; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
981 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
982 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
983 if (p != top()) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
984 gclog_or_tty->print_cr("end of last object "PTR_FORMAT" " |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
985 "does not match top "PTR_FORMAT, p, top()); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
986 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
987 return; |
| 342 | 988 } |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
989 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
990 HeapWord* the_end = end(); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
991 assert(p == top(), "it should still hold"); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
992 // Do some extra BOT consistency checking for addresses in the |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
993 // range [top, end). BOT look-ups in this range should yield |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
994 // top. No point in doing that if top == end (there's nothing there). |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
995 if (p < the_end) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
996 // Look up top |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
997 HeapWord* addr_1 = p; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
998 HeapWord* b_start_1 = _offsets.block_start_const(addr_1); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
999 if (b_start_1 != p) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1000 gclog_or_tty->print_cr("BOT look up for top: "PTR_FORMAT" " |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1001 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1002 addr_1, b_start_1, p); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1003 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1004 return; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1005 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1006 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1007 // Look up top + 1 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1008 HeapWord* addr_2 = p + 1; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1009 if (addr_2 < the_end) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1010 HeapWord* b_start_2 = _offsets.block_start_const(addr_2); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1011 if (b_start_2 != p) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1012 gclog_or_tty->print_cr("BOT look up for top + 1: "PTR_FORMAT" " |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1013 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1014 addr_2, b_start_2, p); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
1015 *failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
1016 return; |
|
2133
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1017 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1018 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1019 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1020 // Look up an address between top and end |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1021 size_t diff = pointer_delta(the_end, p) / 2; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1022 HeapWord* addr_3 = p + diff; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1023 if (addr_3 < the_end) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1024 HeapWord* b_start_3 = _offsets.block_start_const(addr_3); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1025 if (b_start_3 != p) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1026 gclog_or_tty->print_cr("BOT look up for top + diff: "PTR_FORMAT" " |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1027 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1028 addr_3, b_start_3, p); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1029 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1030 return; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1031 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1032 } |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1033 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1034 // Loook up end - 1 |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1035 HeapWord* addr_4 = the_end - 1; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1036 HeapWord* b_start_4 = _offsets.block_start_const(addr_4); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1037 if (b_start_4 != p) { |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1038 gclog_or_tty->print_cr("BOT look up for end - 1: "PTR_FORMAT" " |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1039 " yielded "PTR_FORMAT", expecting "PTR_FORMAT, |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1040 addr_4, b_start_4, p); |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1041 *failures = true; |
|
2250ee17e258
7007068: G1: refine the BOT during evac failure handling
tonyp
parents:
1972
diff
changeset
|
1042 return; |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
1043 } |
| 342 | 1044 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
1045 |
|
1718
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
1046 if (is_humongous && object_num > 1) { |
|
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
1047 gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous " |
|
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
1048 "but has "SIZE_FORMAT", objects", |
|
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
1049 bottom(), end(), object_num); |
|
bb847e31b836
6974928: G1: sometimes humongous objects are allocated in young regions
tonyp
parents:
1705
diff
changeset
|
1050 *failures = true; |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
942
diff
changeset
|
1051 return; |
| 342 | 1052 } |
| 12080 | 1053 |
| 1054 verify_strong_code_roots(vo, failures); | |
| 1055 } | |
| 1056 | |
| 1057 void HeapRegion::verify() const { | |
| 1058 bool dummy = false; | |
| 1059 verify(VerifyOption_G1UsePrevMarking, /* failures */ &dummy); | |
| 342 | 1060 } |
| 1061 | |
| 1062 // G1OffsetTableContigSpace code; copied from space.cpp. Hope this can go | |
| 1063 // away eventually. | |
| 1064 | |
| 356 | 1065 void G1OffsetTableContigSpace::clear(bool mangle_space) { |
| 1066 ContiguousSpace::clear(mangle_space); | |
| 342 | 1067 _offsets.zero_bottom_entry(); |
| 1068 _offsets.initialize_threshold(); | |
| 1069 } | |
| 1070 | |
| 1071 void G1OffsetTableContigSpace::set_bottom(HeapWord* new_bottom) { | |
| 1072 Space::set_bottom(new_bottom); | |
| 1073 _offsets.set_bottom(new_bottom); | |
| 1074 } | |
| 1075 | |
| 1076 void G1OffsetTableContigSpace::set_end(HeapWord* new_end) { | |
| 1077 Space::set_end(new_end); | |
| 1078 _offsets.resize(new_end - bottom()); | |
| 1079 } | |
| 1080 | |
| 1081 void G1OffsetTableContigSpace::print() const { | |
| 1082 print_short(); | |
| 1083 gclog_or_tty->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " | |
| 1084 INTPTR_FORMAT ", " INTPTR_FORMAT ")", | |
| 1085 bottom(), top(), _offsets.threshold(), end()); | |
| 1086 } | |
| 1087 | |
| 1088 HeapWord* G1OffsetTableContigSpace::initialize_threshold() { | |
| 1089 return _offsets.initialize_threshold(); | |
| 1090 } | |
| 1091 | |
| 1092 HeapWord* G1OffsetTableContigSpace::cross_threshold(HeapWord* start, | |
| 1093 HeapWord* end) { | |
| 1094 _offsets.alloc_block(start, end); | |
| 1095 return _offsets.threshold(); | |
| 1096 } | |
| 1097 | |
| 1098 HeapWord* G1OffsetTableContigSpace::saved_mark_word() const { | |
| 1099 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 1100 assert( _gc_time_stamp <= g1h->get_gc_time_stamp(), "invariant" ); | |
| 1101 if (_gc_time_stamp < g1h->get_gc_time_stamp()) | |
| 1102 return top(); | |
| 1103 else | |
| 1104 return ContiguousSpace::saved_mark_word(); | |
| 1105 } | |
| 1106 | |
| 1107 void G1OffsetTableContigSpace::set_saved_mark() { | |
| 1108 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 1109 unsigned curr_gc_time_stamp = g1h->get_gc_time_stamp(); | |
| 1110 | |
| 1111 if (_gc_time_stamp < curr_gc_time_stamp) { | |
| 1112 // The order of these is important, as another thread might be | |
| 1113 // about to start scanning this region. If it does so after | |
| 1114 // set_saved_mark and before _gc_time_stamp = ..., then the latter | |
| 1115 // will be false, and it will pick up top() as the high water mark | |
| 1116 // of region. If it does so after _gc_time_stamp = ..., then it | |
| 1117 // will pick up the right saved_mark_word() as the high water mark | |
| 1118 // of the region. Either way, the behaviour will be correct. | |
| 1119 ContiguousSpace::set_saved_mark(); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
1120 OrderAccess::storestore(); |
|
353
9bb2c10ac07b
6723570: G1: assertion failure: p == current_top or oop(p)->is_oop(),"p is not a block start" (revisited!)
iveresov
parents:
342
diff
changeset
|
1121 _gc_time_stamp = curr_gc_time_stamp; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2152
diff
changeset
|
1122 // No need to do another barrier to flush the writes above. If |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2152
diff
changeset
|
1123 // this is called in parallel with other threads trying to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2152
diff
changeset
|
1124 // allocate into the region, the caller should call this while |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2152
diff
changeset
|
1125 // holding a lock and when the lock is released the writes will be |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2152
diff
changeset
|
1126 // flushed. |
| 342 | 1127 } |
| 1128 } | |
| 1129 | |
| 1130 G1OffsetTableContigSpace:: | |
| 1131 G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray, | |
|
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
1132 MemRegion mr) : |
| 342 | 1133 _offsets(sharedOffsetArray, mr), |
| 1134 _par_alloc_lock(Mutex::leaf, "OffsetTableContigSpace par alloc lock", true), | |
| 1135 _gc_time_stamp(0) | |
| 1136 { | |
| 1137 _offsets.set_space(this); | |
|
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
1138 // false ==> we'll do the clearing if there's clearing to be done. |
|
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
1139 ContiguousSpace::initialize(mr, false, SpaceDecorator::Mangle); |
|
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
1140 _offsets.zero_bottom_entry(); |
|
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6725
diff
changeset
|
1141 _offsets.initialize_threshold(); |
| 342 | 1142 } |