Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp @ 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 | bbfbe9b06038 |
children | 78bbf4d43a14 |
rev | line source |
---|---|
342 | 1 /* |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
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_INLINE_HPP |
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_INLINE_HPP | |
27 | |
3771 | 28 #include "gc_implementation/g1/concurrentMark.inline.hpp" |
1972 | 29 #include "gc_implementation/g1/g1CollectedHeap.hpp" |
30 #include "gc_implementation/g1/g1OopClosures.hpp" | |
31 #include "gc_implementation/g1/g1RemSet.hpp" | |
14391 | 32 #include "gc_implementation/g1/g1RemSet.inline.hpp" |
6251
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
33 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
1972 | 34 |
342 | 35 /* |
36 * This really ought to be an inline function, but apparently the C++ | |
37 * compiler sometimes sees fit to ignore inline declarations. Sigh. | |
38 */ | |
39 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
40 template <class T> |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
41 inline void FilterIntoCSClosure::do_oop_nv(T* p) { |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
42 T heap_oop = oopDesc::load_heap_oop(p); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
43 if (!oopDesc::is_null(heap_oop) && |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
44 _g1->obj_in_cs(oopDesc::decode_heap_oop_not_null(heap_oop))) { |
342 | 45 _oc->do_oop(p); |
46 } | |
47 } | |
48 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
49 template <class T> |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
50 inline void FilterOutOfRegionClosure::do_oop_nv(T* p) { |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
51 T heap_oop = oopDesc::load_heap_oop(p); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
52 if (!oopDesc::is_null(heap_oop)) { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
53 HeapWord* obj_hw = (HeapWord*)oopDesc::decode_heap_oop_not_null(heap_oop); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
54 if (obj_hw < _r_bottom || obj_hw >= _r_end) { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
55 _oc->do_oop(p); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
56 } |
342 | 57 } |
58 } | |
59 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
60 // This closure is applied to the fields of the objects that have just been copied. |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
61 template <class T> |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
62 inline void G1ParScanClosure::do_oop_nv(T* p) { |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
63 T heap_oop = oopDesc::load_heap_oop(p); |
342 | 64 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
65 if (!oopDesc::is_null(heap_oop)) { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
66 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
67 if (_g1->in_cset_fast_test(obj)) { |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
68 // We're not going to even bother checking whether the object is |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
69 // already forwarded or not, as this usually causes an immediate |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
70 // stall. We'll try to prefetch the object (for write, given that |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
71 // we might need to install the forwarding reference) and we'll |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
72 // get back to it when pop it from the queue |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
73 Prefetch::write(obj->mark_addr(), 0); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
74 Prefetch::read(obj->mark_addr(), (HeapWordSize*2)); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
75 |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
76 // slightly paranoid test; I'm trying to catch potential |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
77 // problems before we go into push_on_queue to know where the |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
78 // problem is coming from |
4126
4406629aa157
7114095: G1: assert(obj == oopDesc::load_decode_heap_oop(p)) failed: p should still be pointing to obj
johnc
parents:
3771
diff
changeset
|
79 assert((obj == oopDesc::load_decode_heap_oop(p)) || |
4406629aa157
7114095: G1: assert(obj == oopDesc::load_decode_heap_oop(p)) failed: p should still be pointing to obj
johnc
parents:
3771
diff
changeset
|
80 (obj->is_forwarded() && |
4406629aa157
7114095: G1: assert(obj == oopDesc::load_decode_heap_oop(p)) failed: p should still be pointing to obj
johnc
parents:
3771
diff
changeset
|
81 obj->forwardee() == oopDesc::load_decode_heap_oop(p)), |
4406629aa157
7114095: G1: assert(obj == oopDesc::load_decode_heap_oop(p)) failed: p should still be pointing to obj
johnc
parents:
3771
diff
changeset
|
82 "p should still be pointing to obj or to its forwardee"); |
4406629aa157
7114095: G1: assert(obj == oopDesc::load_decode_heap_oop(p)) failed: p should still be pointing to obj
johnc
parents:
3771
diff
changeset
|
83 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
84 _par_scan_state->push_on_queue(p); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
85 } else { |
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
6862
diff
changeset
|
86 _par_scan_state->update_rs(_from, p, _worker_id); |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
87 } |
342 | 88 } |
89 } | |
1261 | 90 |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
91 template <class T> |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
92 inline void G1ParPushHeapRSClosure::do_oop_nv(T* p) { |
1261 | 93 T heap_oop = oopDesc::load_heap_oop(p); |
94 | |
95 if (!oopDesc::is_null(heap_oop)) { | |
96 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
97 if (_g1->in_cset_fast_test(obj)) { | |
98 Prefetch::write(obj->mark_addr(), 0); | |
99 Prefetch::read(obj->mark_addr(), (HeapWordSize*2)); | |
1705 | 100 |
101 // Place on the references queue | |
1261 | 102 _par_scan_state->push_on_queue(p); |
103 } | |
104 } | |
105 } | |
1705 | 106 |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
107 template <class T> |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
108 inline void G1CMOopClosure::do_oop_nv(T* p) { |
3771 | 109 assert(_g1h->is_in_g1_reserved((HeapWord*) p), "invariant"); |
110 assert(!_g1h->is_on_master_free_list( | |
111 _g1h->heap_region_containing((HeapWord*) p)), "invariant"); | |
112 | |
113 oop obj = oopDesc::load_decode_heap_oop(p); | |
114 if (_cm->verbose_high()) { | |
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6254
diff
changeset
|
115 gclog_or_tty->print_cr("[%u] we're looking at location " |
3771 | 116 "*"PTR_FORMAT" = "PTR_FORMAT, |
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6254
diff
changeset
|
117 _task->worker_id(), p, (void*) obj); |
3771 | 118 } |
119 _task->deal_with_reference(obj); | |
120 } | |
1972 | 121 |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
122 template <class T> |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
123 inline void G1RootRegionScanClosure::do_oop_nv(T* p) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
124 T heap_oop = oopDesc::load_heap_oop(p); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
125 if (!oopDesc::is_null(heap_oop)) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
126 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
127 HeapRegion* hr = _g1h->heap_region_containing((HeapWord*) obj); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
128 if (hr != NULL) { |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
129 _cm->grayRoot(obj, obj->size(), _worker_id, hr); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
130 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
131 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
132 } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
133 |
4839 | 134 template <class T> |
135 inline void G1Mux2Closure::do_oop_nv(T* p) { | |
136 // Apply first closure; then apply the second. | |
137 _c1->do_oop(p); | |
138 _c2->do_oop(p); | |
139 } | |
140 | |
141 template <class T> | |
142 inline void G1TriggerClosure::do_oop_nv(T* p) { | |
143 // Record that this closure was actually applied (triggered). | |
144 _triggered = true; | |
145 } | |
146 | |
147 template <class T> | |
148 inline void G1InvokeIfNotTriggeredClosure::do_oop_nv(T* p) { | |
149 if (!_trigger_cl->triggered()) { | |
150 _oop_cl->do_oop(p); | |
151 } | |
152 } | |
153 | |
154 template <class T> | |
155 inline void G1UpdateRSOrPushRefOopClosure::do_oop_nv(T* p) { | |
156 oop obj = oopDesc::load_decode_heap_oop(p); | |
157 #ifdef ASSERT | |
158 // can't do because of races | |
159 // assert(obj == NULL || obj->is_oop(), "expected an oop"); | |
160 | |
161 // Do the safe subset of is_oop | |
162 if (obj != NULL) { | |
163 #ifdef CHECK_UNHANDLED_OOPS | |
164 oopDesc* o = obj.obj(); | |
165 #else | |
166 oopDesc* o = obj; | |
167 #endif // CHECK_UNHANDLED_OOPS | |
168 assert((intptr_t)o % MinObjAlignmentInBytes == 0, "not oop aligned"); | |
169 assert(Universe::heap()->is_in_reserved(obj), "must be in heap"); | |
170 } | |
171 #endif // ASSERT | |
172 | |
173 assert(_from != NULL, "from region must be non-NULL"); | |
6251
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
174 assert(_from->is_in_reserved(p), "p is not in from"); |
4839 | 175 |
176 HeapRegion* to = _g1->heap_region_containing(obj); | |
177 if (to != NULL && _from != to) { | |
178 // The _record_refs_into_cset flag is true during the RSet | |
179 // updating part of an evacuation pause. It is false at all | |
180 // other times: | |
181 // * rebuilding the rembered sets after a full GC | |
182 // * during concurrent refinement. | |
183 // * updating the remembered sets of regions in the collection | |
184 // set in the event of an evacuation failure (when deferred | |
185 // updates are enabled). | |
186 | |
187 if (_record_refs_into_cset && to->in_collection_set()) { | |
188 // We are recording references that point into the collection | |
189 // set and this particular reference does exactly that... | |
190 // If the referenced object has already been forwarded | |
191 // to itself, we are handling an evacuation failure and | |
192 // we have already visited/tried to copy this object | |
193 // there is no need to retry. | |
194 if (!self_forwarded(obj)) { | |
195 assert(_push_ref_cl != NULL, "should not be null"); | |
196 // Push the reference in the refs queue of the G1ParScanThreadState | |
197 // instance for this worker thread. | |
198 _push_ref_cl->do_oop(p); | |
199 } | |
200 | |
201 // Deferred updates to the CSet are either discarded (in the normal case), | |
202 // or processed (if an evacuation failure occurs) at the end | |
203 // of the collection. | |
204 // See G1RemSet::cleanup_after_oops_into_collection_set_do(). | |
6251
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
205 return; |
4839 | 206 } |
6251
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
207 |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
208 // We either don't care about pushing references that point into the |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
209 // collection set (i.e. we're not during an evacuation pause) _or_ |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
210 // the reference doesn't point into the collection set. Either way |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
211 // we add the reference directly to the RSet of the region containing |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
212 // the referenced object. |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
213 assert(to->rem_set() != NULL, "Need per-region 'into' remsets."); |
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
214 to->rem_set()->add_reference(p, _worker_i); |
4839 | 215 } |
216 } | |
217 | |
1972 | 218 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_INLINE_HPP |