1 /*
2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_INLINE_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_INLINE_HPP
27
28 #include "gc_implementation/g1/concurrentMark.inline.hpp"
29 #include "gc_implementation/g1/g1CollectedHeap.hpp"
30 #include "gc_implementation/g1/g1OopClosures.hpp"
31 #include "gc_implementation/g1/g1RemSet.hpp"
32
33 /*
34 * This really ought to be an inline function, but apparently the C++
35 * compiler sometimes sees fit to ignore inline declarations. Sigh.
36 */
37
38 // This must a ifdef'ed because the counting it controls is in a
39 // perf-critical inner loop.
40 #define FILTERINTOCSCLOSURE_DOHISTOGRAMCOUNT 0
41
42 template <class T>
43 inline void FilterIntoCSClosure::do_oop_nv(T* p) {
44 T heap_oop = oopDesc::load_heap_oop(p);
45 if (!oopDesc::is_null(heap_oop) &&
46 _g1->obj_in_cs(oopDesc::decode_heap_oop_not_null(heap_oop))) {
47 _oc->do_oop(p);
48 #if FILTERINTOCSCLOSURE_DOHISTOGRAMCOUNT
49 if (_dcto_cl != NULL)
50 _dcto_cl->incr_count();
51 #endif
52 }
53 }
54
55 #define FILTEROUTOFREGIONCLOSURE_DOHISTOGRAMCOUNT 0
56
57 template <class T>
58 inline void FilterOutOfRegionClosure::do_oop_nv(T* p) {
59 T heap_oop = oopDesc::load_heap_oop(p);
60 if (!oopDesc::is_null(heap_oop)) {
61 HeapWord* obj_hw = (HeapWord*)oopDesc::decode_heap_oop_not_null(heap_oop);
62 if (obj_hw < _r_bottom || obj_hw >= _r_end) {
63 _oc->do_oop(p);
64 #if FILTEROUTOFREGIONCLOSURE_DOHISTOGRAMCOUNT
65 _out_of_region++;
66 #endif
67 }
68 }
69 }
70
71 // This closure is applied to the fields of the objects that have just been copied.
72 template <class T>
73 inline void G1ParScanClosure::do_oop_nv(T* p) {
74 T heap_oop = oopDesc::load_heap_oop(p);
75
76 if (!oopDesc::is_null(heap_oop)) {
77 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
78 if (_g1->in_cset_fast_test(obj)) {
79 // We're not going to even bother checking whether the object is
80 // already forwarded or not, as this usually causes an immediate
81 // stall. We'll try to prefetch the object (for write, given that
82 // we might need to install the forwarding reference) and we'll
83 // get back to it when pop it from the queue
84 Prefetch::write(obj->mark_addr(), 0);
85 Prefetch::read(obj->mark_addr(), (HeapWordSize*2));
86
87 // slightly paranoid test; I'm trying to catch potential
88 // problems before we go into push_on_queue to know where the
89 // problem is coming from
90 assert((obj == oopDesc::load_decode_heap_oop(p)) ||
91 (obj->is_forwarded() &&
92 obj->forwardee() == oopDesc::load_decode_heap_oop(p)),
93 "p should still be pointing to obj or to its forwardee");
94
95 _par_scan_state->push_on_queue(p);
96 } else {
97 _par_scan_state->update_rs(_from, p, _par_scan_state->queue_num());
98 }
99 }
100 }
101
102 template <class T>
103 inline void G1ParPushHeapRSClosure::do_oop_nv(T* p) {
104 T heap_oop = oopDesc::load_heap_oop(p);
105
106 if (!oopDesc::is_null(heap_oop)) {
107 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
108 if (_g1->in_cset_fast_test(obj)) {
109 Prefetch::write(obj->mark_addr(), 0);
110 Prefetch::read(obj->mark_addr(), (HeapWordSize*2));
111
112 // Place on the references queue
113 _par_scan_state->push_on_queue(p);
114 }
115 }
116 }
117
118 template <class T>
119 inline void G1CMOopClosure::do_oop_nv(T* p) {
120 assert(_g1h->is_in_g1_reserved((HeapWord*) p), "invariant");
121 assert(!_g1h->is_on_master_free_list(
122 _g1h->heap_region_containing((HeapWord*) p)), "invariant");
123
124 oop obj = oopDesc::load_decode_heap_oop(p);
125 if (_cm->verbose_high()) {
126 gclog_or_tty->print_cr("[%d] we're looking at location "
127 "*"PTR_FORMAT" = "PTR_FORMAT,
128 _task->task_id(), p, (void*) obj);
129 }
130 _task->deal_with_reference(obj);
131 }
132
133 template <class T>
134 inline void G1RootRegionScanClosure::do_oop_nv(T* p) {
135 T heap_oop = oopDesc::load_heap_oop(p);
136 if (!oopDesc::is_null(heap_oop)) {
137 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
138 HeapRegion* hr = _g1h->heap_region_containing((HeapWord*) obj);
139 if (hr != NULL) {
140 _cm->grayRoot(obj, obj->size(), _worker_id, hr);
141 }
142 }
143 }
144
145 template <class T>
146 inline void G1Mux2Closure::do_oop_nv(T* p) {
147 // Apply first closure; then apply the second.
148 _c1->do_oop(p);
149 _c2->do_oop(p);
150 }
151
152 template <class T>
153 inline void G1TriggerClosure::do_oop_nv(T* p) {
154 // Record that this closure was actually applied (triggered).
155 _triggered = true;
156 }
157
158 template <class T>
159 inline void G1InvokeIfNotTriggeredClosure::do_oop_nv(T* p) {
160 if (!_trigger_cl->triggered()) {
161 _oop_cl->do_oop(p);
162 }
163 }
164
165 template <class T>
166 inline void G1UpdateRSOrPushRefOopClosure::do_oop_nv(T* p) {
167 oop obj = oopDesc::load_decode_heap_oop(p);
168 #ifdef ASSERT
169 // can't do because of races
170 // assert(obj == NULL || obj->is_oop(), "expected an oop");
171
172 // Do the safe subset of is_oop
173 if (obj != NULL) {
174 #ifdef CHECK_UNHANDLED_OOPS
175 oopDesc* o = obj.obj();
176 #else
177 oopDesc* o = obj;
178 #endif // CHECK_UNHANDLED_OOPS
179 assert((intptr_t)o % MinObjAlignmentInBytes == 0, "not oop aligned");
180 assert(Universe::heap()->is_in_reserved(obj), "must be in heap");
181 }
182 #endif // ASSERT
183
184 assert(_from != NULL, "from region must be non-NULL");
185
186 HeapRegion* to = _g1->heap_region_containing(obj);
187 if (to != NULL && _from != to) {
188 // The _record_refs_into_cset flag is true during the RSet
189 // updating part of an evacuation pause. It is false at all
190 // other times:
191 // * rebuilding the rembered sets after a full GC
192 // * during concurrent refinement.
193 // * updating the remembered sets of regions in the collection
194 // set in the event of an evacuation failure (when deferred
195 // updates are enabled).
196
197 if (_record_refs_into_cset && to->in_collection_set()) {
198 // We are recording references that point into the collection
199 // set and this particular reference does exactly that...
200 // If the referenced object has already been forwarded
201 // to itself, we are handling an evacuation failure and
202 // we have already visited/tried to copy this object
203 // there is no need to retry.
204 if (!self_forwarded(obj)) {
205 assert(_push_ref_cl != NULL, "should not be null");
206 // Push the reference in the refs queue of the G1ParScanThreadState
207 // instance for this worker thread.
208 _push_ref_cl->do_oop(p);
209 }
210
211 // Deferred updates to the CSet are either discarded (in the normal case),
212 // or processed (if an evacuation failure occurs) at the end
213 // of the collection.
214 // See G1RemSet::cleanup_after_oops_into_collection_set_do().
215 } else {
216 // We either don't care about pushing references that point into the
217 // collection set (i.e. we're not during an evacuation pause) _or_
218 // the reference doesn't point into the collection set. Either way
219 // we add the reference directly to the RSet of the region containing
220 // the referenced object.
221 _g1_rem_set->par_write_ref(_from, p, _worker_i);
222 }
223 }
224 }
225
226 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_INLINE_HPP