Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1OopClosures.hpp @ 2431:02f49b66361a
7026932: G1: No need to abort VM when card count cache expansion fails
Summary: Manage allocation/freeing of the card cache counts and epochs arrays directly so that an allocation failure while attempting to expand these arrays does not abort the JVM. Failure to expand these arrays is not fatal.
Reviewed-by: iveresov, tonyp
| author | johnc |
|---|---|
| date | Mon, 28 Mar 2011 10:58:54 -0700 |
| parents | f95d63e2154a |
| children | ae5b2f1dcf12 |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 1972 | 2 * Copyright (c) 2001, 2010, 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:
1261
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
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:
1261
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP | |
| 27 | |
| 342 | 28 class HeapRegion; |
| 29 class G1CollectedHeap; | |
| 30 class G1RemSet; | |
| 31 class ConcurrentMark; | |
| 32 class DirtyCardToOopClosure; | |
| 33 class CMBitMap; | |
| 34 class CMMarkStack; | |
| 35 class G1ParScanThreadState; | |
| 36 | |
| 37 // A class that scans oops in a given heap region (much as OopsInGenClosure | |
| 38 // scans oops in a generation.) | |
| 39 class OopsInHeapRegionClosure: public OopsInGenClosure { | |
| 40 protected: | |
| 41 HeapRegion* _from; | |
| 42 public: | |
| 43 virtual void set_region(HeapRegion* from) { _from = from; } | |
| 44 }; | |
| 45 | |
| 46 class G1ParClosureSuper : public OopsInHeapRegionClosure { | |
| 47 protected: | |
| 48 G1CollectedHeap* _g1; | |
| 49 G1RemSet* _g1_rem; | |
| 50 ConcurrentMark* _cm; | |
| 51 G1ParScanThreadState* _par_scan_state; | |
| 52 public: | |
| 53 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); | |
| 54 bool apply_to_weak_ref_discovered_field() { return true; } | |
| 55 }; | |
| 56 | |
| 1261 | 57 class G1ParPushHeapRSClosure : public G1ParClosureSuper { |
| 58 public: | |
| 59 G1ParPushHeapRSClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : | |
| 60 G1ParClosureSuper(g1, par_scan_state) { } | |
| 61 template <class T> void do_oop_nv(T* p); | |
| 62 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
| 63 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
| 64 }; | |
| 65 | |
| 342 | 66 class G1ParScanClosure : public G1ParClosureSuper { |
| 67 public: | |
| 68 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : | |
| 69 G1ParClosureSuper(g1, par_scan_state) { } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
70 template <class T> void do_oop_nv(T* p); |
| 342 | 71 virtual void do_oop(oop* p) { do_oop_nv(p); } |
| 72 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
| 73 }; | |
| 74 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
75 #define G1_PARTIAL_ARRAY_MASK 0x2 |
| 342 | 76 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
77 template <class T> inline bool has_partial_array_mask(T* ref) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
78 return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK; |
| 526 | 79 } |
| 80 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
81 template <class T> inline T* set_partial_array_mask(T obj) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
82 assert(((uintptr_t)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!"); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
83 return (T*) ((uintptr_t)obj | G1_PARTIAL_ARRAY_MASK); |
| 526 | 84 } |
| 85 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
86 template <class T> inline oop clear_partial_array_mask(T* ref) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
87 return oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK); |
| 526 | 88 } |
| 89 | |
| 342 | 90 class G1ParScanPartialArrayClosure : public G1ParClosureSuper { |
| 91 G1ParScanClosure _scanner; | |
| 92 public: | |
| 93 G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : | |
| 94 G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
95 template <class T> void do_oop_nv(T* p); |
| 342 | 96 virtual void do_oop(oop* p) { do_oop_nv(p); } |
| 97 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
| 98 }; | |
| 99 | |
| 100 | |
| 101 class G1ParCopyHelper : public G1ParClosureSuper { | |
| 102 G1ParScanClosure *_scanner; | |
| 103 protected: | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
104 template <class T> void mark_forwardee(T* p); |
| 342 | 105 oop copy_to_survivor_space(oop obj); |
| 106 public: | |
| 107 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, | |
| 108 G1ParScanClosure *scanner) : | |
| 109 G1ParClosureSuper(g1, par_scan_state), _scanner(scanner) { } | |
| 110 }; | |
| 111 | |
| 526 | 112 template<bool do_gen_barrier, G1Barrier barrier, |
| 1261 | 113 bool do_mark_forwardee> |
| 342 | 114 class G1ParCopyClosure : public G1ParCopyHelper { |
| 115 G1ParScanClosure _scanner; | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
116 template <class T> void do_oop_work(T* p); |
| 342 | 117 public: |
| 118 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : | |
| 119 _scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
120 template <class T> void do_oop_nv(T* p) { |
| 342 | 121 do_oop_work(p); |
| 122 if (do_mark_forwardee) | |
| 123 mark_forwardee(p); | |
| 124 } | |
| 125 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
| 126 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
| 127 }; | |
| 128 | |
| 1261 | 129 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure; |
| 130 typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure; | |
| 131 typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure; | |
| 132 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; | |
| 133 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure; | |
| 134 typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure; | |
| 135 | |
| 526 | 136 // This is the only case when we set skip_cset_test. Basically, this |
| 137 // closure is (should?) only be called directly while we're draining | |
| 138 // the overflow and task queues. In that case we know that the | |
| 139 // reference in question points into the collection set, otherwise we | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
140 // would not have pushed it on the queue. The following is defined in |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
141 // g1_specialized_oop_closures.hpp. |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
142 // typedef G1ParCopyClosure<false, G1BarrierEvac, false, true> G1ParScanHeapEvacClosure; |
| 526 | 143 // We need a separate closure to handle references during evacuation |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
144 // failure processing, as we cannot asume that the reference already |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
145 // points into the collection set (like G1ParScanHeapEvacClosure does). |
| 1261 | 146 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
| 342 | 147 |
| 148 class FilterIntoCSClosure: public OopClosure { | |
| 149 G1CollectedHeap* _g1; | |
| 150 OopClosure* _oc; | |
| 151 DirtyCardToOopClosure* _dcto_cl; | |
| 152 public: | |
| 153 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, | |
| 154 G1CollectedHeap* g1, OopClosure* oc) : | |
| 155 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) | |
| 156 {} | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
157 template <class T> void do_oop_nv(T* p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
158 virtual void do_oop(oop* p) { do_oop_nv(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
159 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 160 bool apply_to_weak_ref_discovered_field() { return true; } |
| 161 bool do_header() { return false; } | |
| 162 }; | |
| 163 | |
| 164 class FilterInHeapRegionAndIntoCSClosure : public OopsInHeapRegionClosure { | |
| 165 G1CollectedHeap* _g1; | |
| 166 OopsInHeapRegionClosure* _oc; | |
| 167 public: | |
| 168 FilterInHeapRegionAndIntoCSClosure(G1CollectedHeap* g1, | |
| 169 OopsInHeapRegionClosure* oc) : | |
| 170 _g1(g1), _oc(oc) | |
| 171 {} | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
172 template <class T> void do_oop_nv(T* p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
173 virtual void do_oop(oop* p) { do_oop_nv(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
174 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 175 bool apply_to_weak_ref_discovered_field() { return true; } |
| 176 bool do_header() { return false; } | |
| 177 void set_region(HeapRegion* from) { | |
| 178 _oc->set_region(from); | |
| 179 } | |
| 180 }; | |
| 181 | |
| 182 class FilterAndMarkInHeapRegionAndIntoCSClosure : public OopsInHeapRegionClosure { | |
| 183 G1CollectedHeap* _g1; | |
| 184 ConcurrentMark* _cm; | |
| 185 OopsInHeapRegionClosure* _oc; | |
| 186 public: | |
| 187 FilterAndMarkInHeapRegionAndIntoCSClosure(G1CollectedHeap* g1, | |
| 188 OopsInHeapRegionClosure* oc, | |
| 189 ConcurrentMark* cm) | |
| 190 : _g1(g1), _oc(oc), _cm(cm) { } | |
| 191 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
192 template <class T> void do_oop_nv(T* p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
193 virtual void do_oop(oop* p) { do_oop_nv(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
194 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 195 bool apply_to_weak_ref_discovered_field() { return true; } |
| 196 bool do_header() { return false; } | |
| 197 void set_region(HeapRegion* from) { | |
| 198 _oc->set_region(from); | |
| 199 } | |
| 200 }; | |
| 201 | |
| 202 class FilterOutOfRegionClosure: public OopClosure { | |
| 203 HeapWord* _r_bottom; | |
| 204 HeapWord* _r_end; | |
| 205 OopClosure* _oc; | |
| 206 int _out_of_region; | |
| 207 public: | |
| 208 FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc); | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
209 template <class T> void do_oop_nv(T* p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
210 virtual void do_oop(oop* p) { do_oop_nv(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
211 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
| 342 | 212 bool apply_to_weak_ref_discovered_field() { return true; } |
| 213 bool do_header() { return false; } | |
| 214 int out_of_region() { return _out_of_region; } | |
| 215 }; | |
| 1972 | 216 |
| 217 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP |