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_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 // 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 inline void ConcurrentMark::markPrev(oop p) {
157 assert(!_prevMarkBitMap->isMarked((HeapWord*) p), "sanity");
158 // Note we are overriding the read-only view of the prev map here, via
159 // the cast.
160 ((CMBitMap*)_prevMarkBitMap)->mark((HeapWord*) p);
161 }
162
163 inline void ConcurrentMark::markNext(oop p) {
164 assert(!_nextMarkBitMap->isMarked((HeapWord*) p), "sanity");
165 _nextMarkBitMap->mark((HeapWord*) p);
166 }
167
168 inline void ConcurrentMark::grayRoot(oop obj, size_t word_size) {
169 HeapWord* addr = (HeapWord*) obj;
170
171 // Currently we don't do anything with word_size but we will use it
172 // in the very near future in the liveness calculation piggy-backing
173 // changes.
174
175 #ifdef ASSERT
176 HeapRegion* hr = _g1h->heap_region_containing(addr);
177 assert(hr != NULL, "sanity");
178 assert(!hr->is_survivor(), "should not allocate survivors during IM");
179 assert(addr < hr->next_top_at_mark_start(),
180 err_msg("addr: "PTR_FORMAT" hr: "HR_FORMAT" NTAMS: "PTR_FORMAT,
181 addr, HR_FORMAT_PARAMS(hr), hr->next_top_at_mark_start()));
182 // We cannot assert that word_size == obj->size() given that obj
183 // might not be in a consistent state (another thread might be in
184 // the process of copying it). So the best thing we can do is to
185 // assert that word_size is under an upper bound which is its
186 // containing region's capacity.
187 assert(word_size * HeapWordSize <= hr->capacity(),
188 err_msg("size: "SIZE_FORMAT" capacity: "SIZE_FORMAT" "HR_FORMAT,
189 word_size * HeapWordSize, hr->capacity(),
190 HR_FORMAT_PARAMS(hr)));
191 #endif // ASSERT
192
193 if (!_nextMarkBitMap->isMarked(addr)) {
194 _nextMarkBitMap->parMark(addr);
195 }
196 }
197
198 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_INLINE_HPP