Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1OopClosures.hpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
author | tamao |
---|---|
date | Tue, 05 Mar 2013 15:36:56 -0800 |
parents | da91efe96a93 |
children | 190899198332 |
rev | line source |
---|---|
342 | 1 /* |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
2 * Copyright (c) 2001, 2012, 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; | |
3771 | 36 class CMTask; |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
37 class ReferenceProcessor; |
342 | 38 |
39 // A class that scans oops in a given heap region (much as OopsInGenClosure | |
40 // scans oops in a generation.) | |
41 class OopsInHeapRegionClosure: public OopsInGenClosure { | |
42 protected: | |
43 HeapRegion* _from; | |
44 public: | |
3765
ae5b2f1dcf12
7045662: G1: OopsInHeapRegionClosure::set_region() should not be virtual
tonyp
parents:
1972
diff
changeset
|
45 void set_region(HeapRegion* from) { _from = from; } |
342 | 46 }; |
47 | |
48 class G1ParClosureSuper : public OopsInHeapRegionClosure { | |
49 protected: | |
50 G1CollectedHeap* _g1; | |
51 G1RemSet* _g1_rem; | |
52 ConcurrentMark* _cm; | |
53 G1ParScanThreadState* _par_scan_state; | |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4787
diff
changeset
|
54 uint _worker_id; |
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3771
diff
changeset
|
55 bool _during_initial_mark; |
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3771
diff
changeset
|
56 bool _mark_in_progress; |
342 | 57 public: |
58 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); | |
59 bool apply_to_weak_ref_discovered_field() { return true; } | |
60 }; | |
61 | |
1261 | 62 class G1ParPushHeapRSClosure : public G1ParClosureSuper { |
63 public: | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
64 G1ParPushHeapRSClosure(G1CollectedHeap* g1, |
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
65 G1ParScanThreadState* par_scan_state): |
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
66 G1ParClosureSuper(g1, par_scan_state) { } |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
67 |
1261 | 68 template <class T> void do_oop_nv(T* p); |
69 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
70 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
71 }; | |
72 | |
342 | 73 class G1ParScanClosure : public G1ParClosureSuper { |
74 public: | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
75 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
76 G1ParClosureSuper(g1, par_scan_state) |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
77 { |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
78 assert(_ref_processor == NULL, "sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
79 _ref_processor = rp; |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
80 } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
81 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
82 template <class T> void do_oop_nv(T* p); |
342 | 83 virtual void do_oop(oop* p) { do_oop_nv(p); } |
84 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
85 }; | |
86 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
87 #define G1_PARTIAL_ARRAY_MASK 0x2 |
342 | 88 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
89 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
|
90 return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK; |
526 | 91 } |
92 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
93 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
|
94 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
|
95 return (T*) ((uintptr_t)obj | G1_PARTIAL_ARRAY_MASK); |
526 | 96 } |
97 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
98 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
|
99 return oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK); |
526 | 100 } |
101 | |
342 | 102 class G1ParScanPartialArrayClosure : public G1ParClosureSuper { |
103 G1ParScanClosure _scanner; | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
104 |
342 | 105 public: |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
106 G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
107 G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state, rp) |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
108 { |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
109 assert(_ref_processor == NULL, "sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
110 } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
111 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
112 G1ParScanClosure* scanner() { |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
113 return &_scanner; |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
114 } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
115 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
116 template <class T> void do_oop_nv(T* p); |
342 | 117 virtual void do_oop(oop* p) { do_oop_nv(p); } |
118 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
119 }; | |
120 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
121 // Add back base class for metadata |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
122 class G1ParCopyHelper : public G1ParClosureSuper { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
123 Klass* _scanned_klass; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
124 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
125 public: |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
126 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
127 _scanned_klass(NULL), |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
128 G1ParClosureSuper(g1, par_scan_state) {} |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
129 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
130 void set_scanned_klass(Klass* k) { _scanned_klass = k; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
131 template <class T> void do_klass_barrier(T* p, oop new_obj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
132 }; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
133 |
5987 | 134 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
135 class G1ParCopyClosure : public G1ParCopyHelper { |
5987 | 136 G1ParScanClosure _scanner; |
137 template <class T> void do_oop_work(T* p); | |
342 | 138 |
139 protected: | |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
140 // Mark the object if it's not already marked. This is used to mark |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
141 // objects pointed to by roots that are guaranteed not to move |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
142 // during the GC (i.e., non-CSet objects). It is MT-safe. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
143 void mark_object(oop obj); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
144 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
145 // Mark the object if it's not already marked. This is used to mark |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
146 // objects pointed to by roots that have been forwarded during a |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
147 // GC. It is MT-safe. |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
148 void mark_forwarded_object(oop from_obj, oop to_obj); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
149 |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
150 oop copy_to_survivor_space(oop obj); |
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
151 |
342 | 152 public: |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
153 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
154 ReferenceProcessor* rp) : |
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
3983
diff
changeset
|
155 _scanner(g1, par_scan_state, rp), |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
156 G1ParCopyHelper(g1, par_scan_state) { |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
157 assert(_ref_processor == NULL, "sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
158 } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
159 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
160 G1ParScanClosure* scanner() { return &_scanner; } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
161 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
162 template <class T> void do_oop_nv(T* p) { |
342 | 163 do_oop_work(p); |
164 } | |
165 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
166 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
167 }; | |
168 | |
1261 | 169 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
170 typedef G1ParCopyClosure<false, G1BarrierKlass, false> G1ParScanMetadataClosure; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
171 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
172 |
1261 | 173 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
174 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkClosure; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
175 typedef G1ParCopyClosure<false, G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure; |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
176 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
177 // The following closure types are no longer used but are retained |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
178 // for historical reasons: |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
179 // typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure; |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
180 // typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure; |
1261 | 181 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
182 // The following closure type is defined in g1_specialized_oop_closures.hpp: |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
183 // |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
184 // typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure; |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
185 |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
186 // We use a separate closure to handle references during evacuation |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
187 // failure processing. |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
188 // We could have used another instance of G1ParScanHeapEvacClosure |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
189 // (since that closure no longer assumes that the references it |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
190 // handles point into the collection set). |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
191 |
1261 | 192 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
342 | 193 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
194 class FilterIntoCSClosure: public ExtendedOopClosure { |
342 | 195 G1CollectedHeap* _g1; |
196 OopClosure* _oc; | |
197 DirtyCardToOopClosure* _dcto_cl; | |
198 public: | |
199 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
200 G1CollectedHeap* g1, |
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
201 OopClosure* oc) : |
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
202 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) { } |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
203 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
204 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
|
205 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
|
206 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
342 | 207 bool apply_to_weak_ref_discovered_field() { return true; } |
208 }; | |
209 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
210 class FilterOutOfRegionClosure: public ExtendedOopClosure { |
342 | 211 HeapWord* _r_bottom; |
212 HeapWord* _r_end; | |
213 OopClosure* _oc; | |
214 public: | |
215 FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc); | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
216 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
|
217 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
|
218 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
342 | 219 bool apply_to_weak_ref_discovered_field() { return true; } |
220 }; | |
1972 | 221 |
3771 | 222 // Closure for iterating over object fields during concurrent marking |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
223 class G1CMOopClosure : public ExtendedOopClosure { |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
224 private: |
3771 | 225 G1CollectedHeap* _g1h; |
226 ConcurrentMark* _cm; | |
227 CMTask* _task; | |
228 public: | |
229 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task); | |
230 template <class T> void do_oop_nv(T* p); | |
231 virtual void do_oop( oop* p) { do_oop_nv(p); } | |
232 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
233 }; | |
234 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
235 // Closure to scan the root regions during concurrent marking |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
236 class G1RootRegionScanClosure : public ExtendedOopClosure { |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
237 private: |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
238 G1CollectedHeap* _g1h; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
239 ConcurrentMark* _cm; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
240 uint _worker_id; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
241 public: |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
242 G1RootRegionScanClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
243 uint worker_id) : |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
244 _g1h(g1h), _cm(cm), _worker_id(worker_id) { } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
245 template <class T> void do_oop_nv(T* p); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
246 virtual void do_oop( oop* p) { do_oop_nv(p); } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
247 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
248 }; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
249 |
4839 | 250 // Closure that applies the given two closures in sequence. |
251 // Used by the RSet refinement code (when updating RSets | |
252 // during an evacuation pause) to record cards containing | |
253 // pointers into the collection set. | |
254 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
255 class G1Mux2Closure : public ExtendedOopClosure { |
4839 | 256 OopClosure* _c1; |
257 OopClosure* _c2; | |
258 public: | |
259 G1Mux2Closure(OopClosure *c1, OopClosure *c2); | |
260 template <class T> void do_oop_nv(T* p); | |
261 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
262 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
263 }; | |
264 | |
265 // A closure that returns true if it is actually applied | |
266 // to a reference | |
267 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
268 class G1TriggerClosure : public ExtendedOopClosure { |
4839 | 269 bool _triggered; |
270 public: | |
271 G1TriggerClosure(); | |
272 bool triggered() const { return _triggered; } | |
273 template <class T> void do_oop_nv(T* p); | |
274 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
275 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
276 }; | |
277 | |
278 // A closure which uses a triggering closure to determine | |
279 // whether to apply an oop closure. | |
280 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
281 class G1InvokeIfNotTriggeredClosure: public ExtendedOopClosure { |
4839 | 282 G1TriggerClosure* _trigger_cl; |
283 OopClosure* _oop_cl; | |
284 public: | |
285 G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t, OopClosure* oc); | |
286 template <class T> void do_oop_nv(T* p); | |
287 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
288 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
289 }; | |
290 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
291 class G1UpdateRSOrPushRefOopClosure: public ExtendedOopClosure { |
4839 | 292 G1CollectedHeap* _g1; |
293 G1RemSet* _g1_rem_set; | |
294 HeapRegion* _from; | |
295 OopsInHeapRegionClosure* _push_ref_cl; | |
296 bool _record_refs_into_cset; | |
297 int _worker_i; | |
298 | |
299 public: | |
300 G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, | |
301 G1RemSet* rs, | |
302 OopsInHeapRegionClosure* push_ref_cl, | |
303 bool record_refs_into_cset, | |
304 int worker_i = 0); | |
305 | |
306 void set_from(HeapRegion* from) { | |
307 assert(from != NULL, "from region must be non-NULL"); | |
308 _from = from; | |
309 } | |
310 | |
311 bool self_forwarded(oop obj) { | |
312 bool result = (obj->is_forwarded() && (obj->forwardee()== obj)); | |
313 return result; | |
314 } | |
315 | |
316 bool apply_to_weak_ref_discovered_field() { return true; } | |
317 | |
318 template <class T> void do_oop_nv(T* p); | |
319 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
320 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
321 }; | |
322 | |
1972 | 323 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP |