tschatzl@6937: /* tschatzl@6937: * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. tschatzl@6937: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. tschatzl@6937: * tschatzl@6937: * This code is free software; you can redistribute it and/or modify it tschatzl@6937: * under the terms of the GNU General Public License version 2 only, as tschatzl@6937: * published by the Free Software Foundation. tschatzl@6937: * tschatzl@6937: * This code is distributed in the hope that it will be useful, but WITHOUT tschatzl@6937: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or tschatzl@6937: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License tschatzl@6937: * version 2 for more details (a copy is included in the LICENSE file that tschatzl@6937: * accompanied this code). tschatzl@6937: * tschatzl@6937: * You should have received a copy of the GNU General Public License version tschatzl@6937: * 2 along with this work; if not, write to the Free Software Foundation, tschatzl@6937: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. tschatzl@6937: * tschatzl@6937: * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA tschatzl@6937: * or visit www.oracle.com if you need additional information or have any tschatzl@6937: * questions. tschatzl@6937: * tschatzl@6937: */ tschatzl@6937: tschatzl@6937: #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_INLINE_HPP tschatzl@6937: #define SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_INLINE_HPP tschatzl@6937: tschatzl@6937: #include "gc_implementation/g1/g1ParScanThreadState.hpp" tschatzl@6937: #include "gc_implementation/g1/g1RemSet.inline.hpp" tschatzl@6937: #include "oops/oop.inline.hpp" tschatzl@6937: tschatzl@6938: template void G1ParScanThreadState::do_oop_evac(T* p, HeapRegion* from) { tschatzl@6938: assert(!oopDesc::is_null(oopDesc::load_decode_heap_oop(p)), tschatzl@6938: "Reference should not be NULL here as such are never pushed to the task queue."); tschatzl@6938: oop obj = oopDesc::load_decode_heap_oop_not_null(p); tschatzl@6938: tschatzl@6938: // Although we never intentionally push references outside of the collection tschatzl@6938: // set, due to (benign) races in the claim mechanism during RSet scanning more tschatzl@6938: // than one thread might claim the same card. So the same card may be tschatzl@6938: // processed multiple times. So redo this check. tschatzl@7651: const InCSetState in_cset_state = _g1h->in_cset_state(obj); tschatzl@7651: if (in_cset_state.is_in_cset()) { tschatzl@6938: oop forwardee; sfriberg@7645: markOop m = obj->mark(); sfriberg@7645: if (m->is_marked()) { sfriberg@7645: forwardee = (oop) m->decode_pointer(); tschatzl@6938: } else { tschatzl@7651: forwardee = copy_to_survivor_space(in_cset_state, obj, m); tschatzl@6938: } tschatzl@6938: oopDesc::encode_store_heap_oop(p, forwardee); tschatzl@7651: } else if (in_cset_state.is_humongous()) { tschatzl@7010: _g1h->set_humongous_is_live(obj); tschatzl@7010: } else { tschatzl@7651: assert(!in_cset_state.is_in_cset_or_humongous(), tschatzl@7651: err_msg("In_cset_state must be NotInCSet here, but is " CSETSTATE_FORMAT, in_cset_state.value())); tschatzl@6938: } tschatzl@6938: tschatzl@6938: assert(obj != NULL, "Must be"); tschatzl@6938: update_rs(from, p, queue_num()); tschatzl@6938: } tschatzl@6938: tschatzl@6937: inline void G1ParScanThreadState::do_oop_partial_array(oop* p) { tschatzl@6937: assert(has_partial_array_mask(p), "invariant"); tschatzl@6937: oop from_obj = clear_partial_array_mask(p); tschatzl@6937: tschatzl@6937: assert(Universe::heap()->is_in_reserved(from_obj), "must be in heap."); tschatzl@6937: assert(from_obj->is_objArray(), "must be obj array"); tschatzl@6937: objArrayOop from_obj_array = objArrayOop(from_obj); tschatzl@6937: // The from-space object contains the real length. tschatzl@6937: int length = from_obj_array->length(); tschatzl@6937: tschatzl@6937: assert(from_obj->is_forwarded(), "must be forwarded"); tschatzl@6937: oop to_obj = from_obj->forwardee(); tschatzl@6937: assert(from_obj != to_obj, "should not be chunking self-forwarded objects"); tschatzl@6937: objArrayOop to_obj_array = objArrayOop(to_obj); tschatzl@6937: // We keep track of the next start index in the length field of the tschatzl@6937: // to-space object. tschatzl@6937: int next_index = to_obj_array->length(); tschatzl@6937: assert(0 <= next_index && next_index < length, tschatzl@6937: err_msg("invariant, next index: %d, length: %d", next_index, length)); tschatzl@6937: tschatzl@6937: int start = next_index; tschatzl@6937: int end = length; tschatzl@6937: int remainder = end - start; tschatzl@6937: // We'll try not to push a range that's smaller than ParGCArrayScanChunk. tschatzl@6937: if (remainder > 2 * ParGCArrayScanChunk) { tschatzl@6937: end = start + ParGCArrayScanChunk; tschatzl@6937: to_obj_array->set_length(end); tschatzl@6937: // Push the remainder before we process the range in case another tschatzl@6937: // worker has run out of things to do and can steal it. tschatzl@6937: oop* from_obj_p = set_partial_array_mask(from_obj); tschatzl@6937: push_on_queue(from_obj_p); tschatzl@6937: } else { tschatzl@6937: assert(length == end, "sanity"); tschatzl@6937: // We'll process the final range for this object. Restore the length tschatzl@6937: // so that the heap remains parsable in case of evacuation failure. tschatzl@6937: to_obj_array->set_length(end); tschatzl@6937: } tschatzl@6937: _scanner.set_region(_g1h->heap_region_containing_raw(to_obj)); tschatzl@6937: // Process indexes [start,end). It will also process the header tschatzl@6937: // along with the first chunk (i.e., the chunk with start == 0). tschatzl@6937: // Note that at this point the length field of to_obj_array is not tschatzl@6937: // correct given that we are using it to keep track of the next tschatzl@6937: // start index. oop_iterate_range() (thankfully!) ignores the length tschatzl@6937: // field and only relies on the start / end parameters. It does tschatzl@6937: // however return the size of the object which will be incorrect. So tschatzl@6937: // we have to ignore it even if we wanted to use it. tschatzl@6937: to_obj_array->oop_iterate_range(&_scanner, start, end); tschatzl@6937: } tschatzl@6937: tschatzl@6937: template inline void G1ParScanThreadState::deal_with_reference(T* ref_to_scan) { tschatzl@6937: if (!has_partial_array_mask(ref_to_scan)) { tschatzl@6937: // Note: we can use "raw" versions of "region_containing" because tschatzl@6937: // "obj_to_scan" is definitely in the heap, and is not in a tschatzl@6937: // humongous region. tschatzl@6937: HeapRegion* r = _g1h->heap_region_containing_raw(ref_to_scan); tschatzl@6937: do_oop_evac(ref_to_scan, r); tschatzl@6937: } else { tschatzl@6937: do_oop_partial_array((oop*)ref_to_scan); tschatzl@6937: } tschatzl@6937: } tschatzl@6937: tschatzl@6938: inline void G1ParScanThreadState::dispatch_reference(StarTask ref) { tschatzl@6937: assert(verify_task(ref), "sanity"); tschatzl@6937: if (ref.is_narrow()) { tschatzl@6937: deal_with_reference((narrowOop*)ref); tschatzl@6937: } else { tschatzl@6937: deal_with_reference((oop*)ref); tschatzl@6937: } tschatzl@6937: } tschatzl@6937: tschatzl@6938: void G1ParScanThreadState::steal_and_trim_queue(RefToScanQueueSet *task_queues) { tschatzl@6938: StarTask stolen_task; tschatzl@6938: while (task_queues->steal(queue_num(), hash_seed(), stolen_task)) { tschatzl@6938: assert(verify_task(stolen_task), "sanity"); tschatzl@6938: dispatch_reference(stolen_task); tschatzl@6938: tschatzl@6938: // We've just processed a reference and we might have made tschatzl@6938: // available new entries on the queues. So we have to make sure tschatzl@6938: // we drain the queues as necessary. tschatzl@6938: trim_queue(); tschatzl@6938: } tschatzl@6938: } tschatzl@6938: tschatzl@6937: #endif /* SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_INLINE_HPP */ tschatzl@6937: