Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1OopClosures.inline.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | a2f7274eb6ef |
| children | 63a4eb8bcd23 d2907f74462e 86b64209f715 |
| 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" | |
|
6251
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
32 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
| 1972 | 33 |
| 342 | 34 /* |
| 35 * This really ought to be an inline function, but apparently the C++ | |
| 36 * compiler sometimes sees fit to ignore inline declarations. Sigh. | |
| 37 */ | |
| 38 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
39 template <class T> |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
40 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
|
41 T heap_oop = oopDesc::load_heap_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
42 if (!oopDesc::is_null(heap_oop) && |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
43 _g1->obj_in_cs(oopDesc::decode_heap_oop_not_null(heap_oop))) { |
| 342 | 44 _oc->do_oop(p); |
| 45 } | |
| 46 } | |
| 47 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
48 template <class T> |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
49 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
|
50 T heap_oop = oopDesc::load_heap_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
51 if (!oopDesc::is_null(heap_oop)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
52 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
|
53 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
|
54 _oc->do_oop(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
55 } |
| 342 | 56 } |
| 57 } | |
| 58 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
59 // 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
|
60 template <class T> |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
61 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
|
62 T heap_oop = oopDesc::load_heap_oop(p); |
| 342 | 63 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
64 if (!oopDesc::is_null(heap_oop)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
65 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
|
66 if (_g1->in_cset_fast_test(obj)) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
67 // 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
|
68 // 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
|
69 // 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
|
70 // 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
|
71 // 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
|
72 Prefetch::write(obj->mark_addr(), 0); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
73 Prefetch::read(obj->mark_addr(), (HeapWordSize*2)); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
74 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
75 // 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
|
76 // 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
|
77 // 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
|
78 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
|
79 (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
|
80 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
|
81 "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
|
82 |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
83 _par_scan_state->push_on_queue(p); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
84 } else { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
85 _par_scan_state->update_rs(_from, p, _par_scan_state->queue_num()); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
342
diff
changeset
|
86 } |
| 342 | 87 } |
| 88 } | |
| 1261 | 89 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
90 template <class T> |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
91 inline void G1ParPushHeapRSClosure::do_oop_nv(T* p) { |
| 1261 | 92 T heap_oop = oopDesc::load_heap_oop(p); |
| 93 | |
| 94 if (!oopDesc::is_null(heap_oop)) { | |
| 95 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 96 if (_g1->in_cset_fast_test(obj)) { | |
| 97 Prefetch::write(obj->mark_addr(), 0); | |
| 98 Prefetch::read(obj->mark_addr(), (HeapWordSize*2)); | |
| 1705 | 99 |
| 100 // Place on the references queue | |
| 1261 | 101 _par_scan_state->push_on_queue(p); |
| 102 } | |
| 103 } | |
| 104 } | |
| 1705 | 105 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
106 template <class T> |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
107 inline void G1CMOopClosure::do_oop_nv(T* p) { |
| 3771 | 108 assert(_g1h->is_in_g1_reserved((HeapWord*) p), "invariant"); |
| 109 assert(!_g1h->is_on_master_free_list( | |
| 110 _g1h->heap_region_containing((HeapWord*) p)), "invariant"); | |
| 111 | |
| 112 oop obj = oopDesc::load_decode_heap_oop(p); | |
| 113 if (_cm->verbose_high()) { | |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6254
diff
changeset
|
114 gclog_or_tty->print_cr("[%u] we're looking at location " |
| 3771 | 115 "*"PTR_FORMAT" = "PTR_FORMAT, |
|
6862
8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents:
6254
diff
changeset
|
116 _task->worker_id(), p, (void*) obj); |
| 3771 | 117 } |
| 118 _task->deal_with_reference(obj); | |
| 119 } | |
| 1972 | 120 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
121 template <class T> |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
122 inline void G1RootRegionScanClosure::do_oop_nv(T* p) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
123 T heap_oop = oopDesc::load_heap_oop(p); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
124 if (!oopDesc::is_null(heap_oop)) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
125 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
|
126 HeapRegion* hr = _g1h->heap_region_containing((HeapWord*) obj); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
127 if (hr != NULL) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
128 _cm->grayRoot(obj, obj->size(), _worker_id, hr); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4126
diff
changeset
|
129 } |
|
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 |
| 4839 | 133 template <class T> |
| 134 inline void G1Mux2Closure::do_oop_nv(T* p) { | |
| 135 // Apply first closure; then apply the second. | |
| 136 _c1->do_oop(p); | |
| 137 _c2->do_oop(p); | |
| 138 } | |
| 139 | |
| 140 template <class T> | |
| 141 inline void G1TriggerClosure::do_oop_nv(T* p) { | |
| 142 // Record that this closure was actually applied (triggered). | |
| 143 _triggered = true; | |
| 144 } | |
| 145 | |
| 146 template <class T> | |
| 147 inline void G1InvokeIfNotTriggeredClosure::do_oop_nv(T* p) { | |
| 148 if (!_trigger_cl->triggered()) { | |
| 149 _oop_cl->do_oop(p); | |
| 150 } | |
| 151 } | |
| 152 | |
| 153 template <class T> | |
| 154 inline void G1UpdateRSOrPushRefOopClosure::do_oop_nv(T* p) { | |
| 155 oop obj = oopDesc::load_decode_heap_oop(p); | |
| 156 #ifdef ASSERT | |
| 157 // can't do because of races | |
| 158 // assert(obj == NULL || obj->is_oop(), "expected an oop"); | |
| 159 | |
| 160 // Do the safe subset of is_oop | |
| 161 if (obj != NULL) { | |
| 162 #ifdef CHECK_UNHANDLED_OOPS | |
| 163 oopDesc* o = obj.obj(); | |
| 164 #else | |
| 165 oopDesc* o = obj; | |
| 166 #endif // CHECK_UNHANDLED_OOPS | |
| 167 assert((intptr_t)o % MinObjAlignmentInBytes == 0, "not oop aligned"); | |
| 168 assert(Universe::heap()->is_in_reserved(obj), "must be in heap"); | |
| 169 } | |
| 170 #endif // ASSERT | |
| 171 | |
| 172 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
|
173 assert(_from->is_in_reserved(p), "p is not in from"); |
| 4839 | 174 |
| 175 HeapRegion* to = _g1->heap_region_containing(obj); | |
| 176 if (to != NULL && _from != to) { | |
| 177 // The _record_refs_into_cset flag is true during the RSet | |
| 178 // updating part of an evacuation pause. It is false at all | |
| 179 // other times: | |
| 180 // * rebuilding the rembered sets after a full GC | |
| 181 // * during concurrent refinement. | |
| 182 // * updating the remembered sets of regions in the collection | |
| 183 // set in the event of an evacuation failure (when deferred | |
| 184 // updates are enabled). | |
| 185 | |
| 186 if (_record_refs_into_cset && to->in_collection_set()) { | |
| 187 // We are recording references that point into the collection | |
| 188 // set and this particular reference does exactly that... | |
| 189 // If the referenced object has already been forwarded | |
| 190 // to itself, we are handling an evacuation failure and | |
| 191 // we have already visited/tried to copy this object | |
| 192 // there is no need to retry. | |
| 193 if (!self_forwarded(obj)) { | |
| 194 assert(_push_ref_cl != NULL, "should not be null"); | |
| 195 // Push the reference in the refs queue of the G1ParScanThreadState | |
| 196 // instance for this worker thread. | |
| 197 _push_ref_cl->do_oop(p); | |
| 198 } | |
| 199 | |
| 200 // Deferred updates to the CSet are either discarded (in the normal case), | |
| 201 // or processed (if an evacuation failure occurs) at the end | |
| 202 // of the collection. | |
| 203 // 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
|
204 return; |
| 4839 | 205 } |
|
6251
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
206 |
|
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
207 // 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
|
208 // 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
|
209 // 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
|
210 // 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
|
211 // the referenced object. |
|
594dff5e3c2e
7173712: G1: Duplicated code in G1UpdateRSOrPushRefOopClosure::do_oop_nv()
johnc
parents:
4839
diff
changeset
|
212 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
|
213 to->rem_set()->add_reference(p, _worker_i); |
| 4839 | 214 } |
| 215 } | |
| 216 | |
| 1972 | 217 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_INLINE_HPP |