149 }
150 return false;
151 }
152
153 // Attempts to mark the given object and, if successful, counts
154 // the object in the task/worker counting structures for the
155 // given worker id.
156 inline bool ConcurrentMark::par_mark_and_count(oop obj,
157 size_t word_size,
158 HeapRegion* hr,
159 uint worker_id) {
160 HeapWord* addr = (HeapWord*)obj;
161 if (_nextMarkBitMap->parMark(addr)) {
162 MemRegion mr(addr, word_size);
163 count_region(mr, hr, worker_id);
164 return true;
165 }
166 return false;
167 }
168
169 inline bool CMBitMapRO::iterate(BitMapClosure* cl, MemRegion mr) {
170 HeapWord* start_addr = MAX2(startWord(), mr.start());
171 HeapWord* end_addr = MIN2(endWord(), mr.end());
172
173 if (end_addr > start_addr) {
174 // Right-open interval [start-offset, end-offset).
175 BitMap::idx_t start_offset = heapWordToOffset(start_addr);
176 BitMap::idx_t end_offset = heapWordToOffset(end_addr);
177
178 start_offset = _bm.get_next_one_offset(start_offset, end_offset);
179 while (start_offset < end_offset) {
180 if (!cl->do_bit(start_offset)) {
181 return false;
182 }
183 HeapWord* next_addr = MIN2(nextObject(offsetToHeapWord(start_offset)), end_addr);
184 BitMap::idx_t next_offset = heapWordToOffset(next_addr);
185 start_offset = _bm.get_next_one_offset(next_offset, end_offset);
186 }
187 }
188 return true;
189 }
190
191 inline bool CMBitMapRO::iterate(BitMapClosure* cl) {
192 MemRegion mr(startWord(), sizeInWords());
193 return iterate(cl, mr);
194 }
195
196 #define check_mark(addr) \
197 assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize), \
198 "outside underlying space?"); \
199 assert(G1CollectedHeap::heap()->is_in_exact(addr), \
200 err_msg("Trying to access not available bitmap " PTR_FORMAT \
201 " corresponding to " PTR_FORMAT " (%u)", \
202 p2i(this), p2i(addr), G1CollectedHeap::heap()->addr_to_region(addr)));
203
204 inline void CMBitMap::mark(HeapWord* addr) {
205 check_mark(addr);
206 _bm.set_bit(heapWordToOffset(addr));
207 }
208
209 inline void CMBitMap::clear(HeapWord* addr) {
210 check_mark(addr);
211 _bm.clear_bit(heapWordToOffset(addr));
212 }
213
214 inline bool CMBitMap::parMark(HeapWord* addr) {
215 check_mark(addr);
216 return _bm.par_set_bit(heapWordToOffset(addr));
217 }
218
219 inline bool CMBitMap::parClear(HeapWord* addr) {
220 check_mark(addr);
221 return _bm.par_clear_bit(heapWordToOffset(addr));
222 }
223
224 #undef check_mark
225
226 template<typename Fn>
227 inline void CMMarkStack::iterate(Fn fn) {
228 assert(_saved_index == _index,
229 err_msg("saved index: %d index: %d", _saved_index, _index));
230 for (int i = 0; i < _index; ++i) {
231 fn(_base[i]);
232 }
233 }
234
235 // It scans an object and visits its children.
236 inline void CMTask::scan_object(oop obj) { process_grey_object<true>(obj); }
237
238 inline void CMTask::push(oop obj) {
239 HeapWord* objAddr = (HeapWord*) obj;
240 assert(_g1h->is_in_g1_reserved(objAddr), "invariant");
241 assert(!_g1h->is_on_master_free_list(
242 _g1h->heap_region_containing((HeapWord*) objAddr)), "invariant");
243 assert(!_g1h->is_obj_ill(obj), "invariant");
244 assert(_nextMarkBitMap->isMarked(objAddr), "invariant");
245
|
149 }
150 return false;
151 }
152
153 // Attempts to mark the given object and, if successful, counts
154 // the object in the task/worker counting structures for the
155 // given worker id.
156 inline bool ConcurrentMark::par_mark_and_count(oop obj,
157 size_t word_size,
158 HeapRegion* hr,
159 uint worker_id) {
160 HeapWord* addr = (HeapWord*)obj;
161 if (_nextMarkBitMap->parMark(addr)) {
162 MemRegion mr(addr, word_size);
163 count_region(mr, hr, worker_id);
164 return true;
165 }
166 return false;
167 }
168
169 template<typename Fn>
170 inline void CMMarkStack::iterate(Fn fn) {
171 assert(_saved_index == _index,
172 err_msg("saved index: %d index: %d", _saved_index, _index));
173 for (int i = 0; i < _index; ++i) {
174 fn(_base[i]);
175 }
176 }
177
178 // It scans an object and visits its children.
179 inline void CMTask::scan_object(oop obj) { process_grey_object<true>(obj); }
180
181 inline void CMTask::push(oop obj) {
182 HeapWord* objAddr = (HeapWord*) obj;
183 assert(_g1h->is_in_g1_reserved(objAddr), "invariant");
184 assert(!_g1h->is_on_master_free_list(
185 _g1h->heap_region_containing((HeapWord*) objAddr)), "invariant");
186 assert(!_g1h->is_obj_ill(obj), "invariant");
187 assert(_nextMarkBitMap->isMarked(objAddr), "invariant");
188
|