Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | 23d434c6290d |
| children | 2ace1c4ee8da |
| rev | line source |
|---|---|
| 3771 | 1 /* |
| 2 * Copyright (c) 2001, 2011, 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_CONCURRENTMARK_INLINE_HPP | |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP | |
| 27 | |
| 28 #include "gc_implementation/g1/concurrentMark.hpp" | |
| 29 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 30 | |
| 31 inline void CMTask::push(oop obj) { | |
| 32 HeapWord* objAddr = (HeapWord*) obj; | |
| 33 assert(_g1h->is_in_g1_reserved(objAddr), "invariant"); | |
| 34 assert(!_g1h->is_on_master_free_list( | |
| 35 _g1h->heap_region_containing((HeapWord*) objAddr)), "invariant"); | |
| 36 assert(!_g1h->is_obj_ill(obj), "invariant"); | |
| 37 assert(_nextMarkBitMap->isMarked(objAddr), "invariant"); | |
| 38 | |
| 39 if (_cm->verbose_high()) { | |
| 40 gclog_or_tty->print_cr("[%d] pushing "PTR_FORMAT, _task_id, (void*) obj); | |
| 41 } | |
| 42 | |
| 43 if (!_task_queue->push(obj)) { | |
| 44 // The local task queue looks full. We need to push some entries | |
| 45 // to the global stack. | |
| 46 | |
| 47 if (_cm->verbose_medium()) { | |
| 48 gclog_or_tty->print_cr("[%d] task queue overflow, " | |
| 49 "moving entries to the global stack", | |
| 50 _task_id); | |
| 51 } | |
| 52 move_entries_to_global_stack(); | |
| 53 | |
| 54 // this should succeed since, even if we overflow the global | |
| 55 // stack, we should have definitely removed some entries from the | |
| 56 // local queue. So, there must be space on it. | |
| 57 bool success = _task_queue->push(obj); | |
| 58 assert(success, "invariant"); | |
| 59 } | |
| 60 | |
| 61 statsOnly( int tmp_size = _task_queue->size(); | |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3771
diff
changeset
|
62 if (tmp_size > _local_max_size) { |
| 3771 | 63 _local_max_size = tmp_size; |
|
3776
23d434c6290d
7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents:
3771
diff
changeset
|
64 } |
| 3771 | 65 ++_local_pushes ); |
| 66 } | |
| 67 | |
| 68 // This determines whether the method below will check both the local | |
| 69 // and global fingers when determining whether to push on the stack a | |
| 70 // gray object (value 1) or whether it will only check the global one | |
| 71 // (value 0). The tradeoffs are that the former will be a bit more | |
| 72 // accurate and possibly push less on the stack, but it might also be | |
| 73 // a little bit slower. | |
| 74 | |
| 75 #define _CHECK_BOTH_FINGERS_ 1 | |
| 76 | |
| 77 inline void CMTask::deal_with_reference(oop obj) { | |
| 78 if (_cm->verbose_high()) { | |
| 79 gclog_or_tty->print_cr("[%d] we're dealing with reference = "PTR_FORMAT, | |
| 80 _task_id, (void*) obj); | |
| 81 } | |
| 82 | |
| 83 ++_refs_reached; | |
| 84 | |
| 85 HeapWord* objAddr = (HeapWord*) obj; | |
| 86 assert(obj->is_oop_or_null(true /* ignore mark word */), "Error"); | |
| 87 if (_g1h->is_in_g1_reserved(objAddr)) { | |
| 88 assert(obj != NULL, "null check is implicit"); | |
| 89 if (!_nextMarkBitMap->isMarked(objAddr)) { | |
| 90 // Only get the containing region if the object is not marked on the | |
| 91 // bitmap (otherwise, it's a waste of time since we won't do | |
| 92 // anything with it). | |
| 93 HeapRegion* hr = _g1h->heap_region_containing_raw(obj); | |
| 94 if (!hr->obj_allocated_since_next_marking(obj)) { | |
| 95 if (_cm->verbose_high()) { | |
| 96 gclog_or_tty->print_cr("[%d] "PTR_FORMAT" is not considered marked", | |
| 97 _task_id, (void*) obj); | |
| 98 } | |
| 99 | |
| 100 // we need to mark it first | |
| 101 if (_nextMarkBitMap->parMark(objAddr)) { | |
| 102 // No OrderAccess:store_load() is needed. It is implicit in the | |
| 103 // CAS done in parMark(objAddr) above | |
| 104 HeapWord* global_finger = _cm->finger(); | |
| 105 | |
| 106 #if _CHECK_BOTH_FINGERS_ | |
| 107 // we will check both the local and global fingers | |
| 108 | |
| 109 if (_finger != NULL && objAddr < _finger) { | |
| 110 if (_cm->verbose_high()) { | |
| 111 gclog_or_tty->print_cr("[%d] below the local finger ("PTR_FORMAT"), " | |
| 112 "pushing it", _task_id, _finger); | |
| 113 } | |
| 114 push(obj); | |
| 115 } else if (_curr_region != NULL && objAddr < _region_limit) { | |
| 116 // do nothing | |
| 117 } else if (objAddr < global_finger) { | |
| 118 // Notice that the global finger might be moving forward | |
| 119 // concurrently. This is not a problem. In the worst case, we | |
| 120 // mark the object while it is above the global finger and, by | |
| 121 // the time we read the global finger, it has moved forward | |
| 122 // passed this object. In this case, the object will probably | |
| 123 // be visited when a task is scanning the region and will also | |
| 124 // be pushed on the stack. So, some duplicate work, but no | |
| 125 // correctness problems. | |
| 126 | |
| 127 if (_cm->verbose_high()) { | |
| 128 gclog_or_tty->print_cr("[%d] below the global finger " | |
| 129 "("PTR_FORMAT"), pushing it", | |
| 130 _task_id, global_finger); | |
| 131 } | |
| 132 push(obj); | |
| 133 } else { | |
| 134 // do nothing | |
| 135 } | |
| 136 #else // _CHECK_BOTH_FINGERS_ | |
| 137 // we will only check the global finger | |
| 138 | |
| 139 if (objAddr < global_finger) { | |
| 140 // see long comment above | |
| 141 | |
| 142 if (_cm->verbose_high()) { | |
| 143 gclog_or_tty->print_cr("[%d] below the global finger " | |
| 144 "("PTR_FORMAT"), pushing it", | |
| 145 _task_id, global_finger); | |
| 146 } | |
| 147 push(obj); | |
| 148 } | |
| 149 #endif // _CHECK_BOTH_FINGERS_ | |
| 150 } | |
| 151 } | |
| 152 } | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP |