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(); 62 if (tmp_size > _local_max_size) { 63 _local_max_size = tmp_size; 64 } 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 // Update the task specific count data with obj. 103 _cm->add_to_count_data_for(obj, hr, _task_id); 104 105 // No OrderAccess:store_load() is needed. It is implicit in the 106 // CAS done in parMark(objAddr) above 107 HeapWord* global_finger = _cm->finger(); 108 109 #if _CHECK_BOTH_FINGERS_ 110 // we will check both the local and global fingers 111 112 if (_finger != NULL && objAddr < _finger) { 113 if (_cm->verbose_high()) { 114 gclog_or_tty->print_cr("[%d] below the local finger ("PTR_FORMAT"), " 115 "pushing it", _task_id, _finger); 116 } 117 push(obj); 118 } else if (_curr_region != NULL && objAddr < _region_limit) { 119 // do nothing 120 } else if (objAddr < global_finger) { 121 // Notice that the global finger might be moving forward 122 // concurrently. This is not a problem. In the worst case, we 123 // mark the object while it is above the global finger and, by 124 // the time we read the global finger, it has moved forward 125 // passed this object. In this case, the object will probably 126 // be visited when a task is scanning the region and will also 127 // be pushed on the stack. So, some duplicate work, but no 128 // correctness problems. 129 130 if (_cm->verbose_high()) { 131 gclog_or_tty->print_cr("[%d] below the global finger " 132 "("PTR_FORMAT"), pushing it", 133 _task_id, global_finger); 134 } 135 push(obj); 136 } else { 137 // do nothing 138 } 139 #else // _CHECK_BOTH_FINGERS_ 140 // we will only check the global finger 141 142 if (objAddr < global_finger) { 143 // see long comment above 144 145 if (_cm->verbose_high()) { 146 gclog_or_tty->print_cr("[%d] below the global finger " 147 "("PTR_FORMAT"), pushing it", 148 _task_id, global_finger); 149 } 150 push(obj); 151 } 152 #endif // _CHECK_BOTH_FINGERS_ 153 } 154 } 155 } 156 } 157 } 158 159 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP