Mercurial > hg > graal-compiler
view src/share/vm/oops/objArrayKlass.cpp @ 2149:7e37af9d69ef
7011379: G1: overly long concurrent marking cycles
Summary: This changeset introduces filtering of SATB buffers at the point when they are about to be enqueued. If this filtering clears enough entries on each buffer, the buffer can then be re-used and not enqueued. This cuts down the number of SATB buffers that need to be processed by the concurrent marking threads.
Reviewed-by: johnc, ysr
author | tonyp |
---|---|
date | Wed, 19 Jan 2011 09:35:17 -0500 |
parents | d4fca0a6abde |
children | 3582bf76420e |
line wrap: on
line source
/* * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #include "precompiled.hpp" #include "classfile/systemDictionary.hpp" #include "classfile/vmSymbols.hpp" #include "gc_implementation/shared/markSweep.inline.hpp" #include "gc_interface/collectedHeap.inline.hpp" #include "memory/genOopClosures.inline.hpp" #include "memory/resourceArea.hpp" #include "memory/universe.inline.hpp" #include "oops/instanceKlass.hpp" #include "oops/objArrayKlass.hpp" #include "oops/objArrayKlass.inline.hpp" #include "oops/objArrayKlassKlass.hpp" #include "oops/objArrayOop.hpp" #include "oops/oop.inline.hpp" #include "oops/oop.inline2.hpp" #include "oops/symbolOop.hpp" #include "runtime/handles.inline.hpp" #include "runtime/mutexLocker.hpp" #include "utilities/copy.hpp" #ifndef SERIALGC #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" #include "gc_implementation/g1/g1OopClosures.inline.hpp" #include "gc_implementation/g1/g1RemSet.inline.hpp" #include "gc_implementation/g1/heapRegionSeq.inline.hpp" #include "gc_implementation/parNew/parOopClosures.inline.hpp" #include "gc_implementation/parallelScavenge/psCompactionManager.hpp" #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" #include "oops/oop.pcgc.inline.hpp" #endif int objArrayKlass::oop_size(oop obj) const { assert(obj->is_objArray(), "must be object array"); return objArrayOop(obj)->object_size(); } objArrayOop objArrayKlass::allocate(int length, TRAPS) { if (length >= 0) { if (length <= arrayOopDesc::max_array_length(T_OBJECT)) { int size = objArrayOopDesc::object_size(length); KlassHandle h_k(THREAD, as_klassOop()); objArrayOop a = (objArrayOop)CollectedHeap::array_allocate(h_k, size, length, CHECK_NULL); assert(a->is_parsable(), "Can't publish unless parsable"); return a; } else { report_java_out_of_memory("Requested array size exceeds VM limit"); THROW_OOP_0(Universe::out_of_memory_error_array_size()); } } else { THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); } } static int multi_alloc_counter = 0; oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) { int length = *sizes; // Call to lower_dimension uses this pointer, so most be called before a // possible GC KlassHandle h_lower_dimension(THREAD, lower_dimension()); // If length < 0 allocate will throw an exception. objArrayOop array = allocate(length, CHECK_NULL); assert(array->is_parsable(), "Don't handlize unless parsable"); objArrayHandle h_array (THREAD, array); if (rank > 1) { if (length != 0) { for (int index = 0; index < length; index++) { arrayKlass* ak = arrayKlass::cast(h_lower_dimension()); oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL); assert(sub_array->is_parsable(), "Don't publish until parsable"); h_array->obj_at_put(index, sub_array); } } else { // Since this array dimension has zero length, nothing will be // allocated, however the lower dimension values must be checked // for illegal values. for (int i = 0; i < rank - 1; ++i) { sizes += 1; if (*sizes < 0) { THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); } } } } return h_array(); } // Either oop or narrowOop depending on UseCompressedOops. template <class T> void objArrayKlass::do_copy(arrayOop s, T* src, arrayOop d, T* dst, int length, TRAPS) { BarrierSet* bs = Universe::heap()->barrier_set(); // For performance reasons, we assume we are that the write barrier we // are using has optimized modes for arrays of references. At least one // of the asserts below will fail if this is not the case. assert(bs->has_write_ref_array_opt(), "Barrier set must have ref array opt"); assert(bs->has_write_ref_array_pre_opt(), "For pre-barrier as well."); if (s == d) { // since source and destination are equal we do not need conversion checks. assert(length > 0, "sanity check"); bs->write_ref_array_pre(dst, length); Copy::conjoint_oops_atomic(src, dst, length); } else { // We have to make sure all elements conform to the destination array klassOop bound = objArrayKlass::cast(d->klass())->element_klass(); klassOop stype = objArrayKlass::cast(s->klass())->element_klass(); if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) { // elements are guaranteed to be subtypes, so no check necessary bs->write_ref_array_pre(dst, length); Copy::conjoint_oops_atomic(src, dst, length); } else { // slow case: need individual subtype checks // note: don't use obj_at_put below because it includes a redundant store check T* from = src; T* end = from + length; for (T* p = dst; from < end; from++, p++) { // XXX this is going to be slow. T element = *from; // even slower now bool element_is_null = oopDesc::is_null(element); oop new_val = element_is_null ? oop(NULL) : oopDesc::decode_heap_oop_not_null(element); if (element_is_null || Klass::cast((new_val->klass()))->is_subtype_of(bound)) { bs->write_ref_field_pre(p, new_val); *p = *from; } else { // We must do a barrier to cover the partial copy. const size_t pd = pointer_delta(p, dst, (size_t)heapOopSize); // pointer delta is scaled to number of elements (length field in // objArrayOop) which we assume is 32 bit. assert(pd == (size_t)(int)pd, "length field overflow"); bs->write_ref_array((HeapWord*)dst, pd); THROW(vmSymbols::java_lang_ArrayStoreException()); return; } } } } bs->write_ref_array((HeapWord*)dst, length); } void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) { assert(s->is_objArray(), "must be obj array"); if (!d->is_objArray()) { THROW(vmSymbols::java_lang_ArrayStoreException()); } // Check is all offsets and lengths are non negative if (src_pos < 0 || dst_pos < 0 || length < 0) { THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); } // Check if the ranges are valid if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length()) || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) { THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); } // Special case. Boundary cases must be checked first // This allows the following call: copy_array(s, s.length(), d.length(), 0). // This is correct, since the position is supposed to be an 'in between point', i.e., s.length(), // points to the right of the last element. if (length==0) { return; } if (UseCompressedOops) { narrowOop* const src = objArrayOop(s)->obj_at_addr<narrowOop>(src_pos); narrowOop* const dst = objArrayOop(d)->obj_at_addr<narrowOop>(dst_pos); do_copy<narrowOop>(s, src, d, dst, length, CHECK); } else { oop* const src = objArrayOop(s)->obj_at_addr<oop>(src_pos); oop* const dst = objArrayOop(d)->obj_at_addr<oop>(dst_pos); do_copy<oop> (s, src, d, dst, length, CHECK); } } klassOop objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { objArrayKlassHandle h_this(THREAD, as_klassOop()); return array_klass_impl(h_this, or_null, n, CHECK_NULL); } klassOop objArrayKlass::array_klass_impl(objArrayKlassHandle this_oop, bool or_null, int n, TRAPS) { assert(this_oop->dimension() <= n, "check order of chain"); int dimension = this_oop->dimension(); if (dimension == n) return this_oop(); objArrayKlassHandle ak (THREAD, this_oop->higher_dimension()); if (ak.is_null()) { if (or_null) return NULL; ResourceMark rm; JavaThread *jt = (JavaThread *)THREAD; { MutexLocker mc(Compile_lock, THREAD); // for vtables // Ensure atomic creation of higher dimensions MutexLocker mu(MultiArray_lock, THREAD); // Check if another thread beat us ak = objArrayKlassHandle(THREAD, this_oop->higher_dimension()); if( ak.is_null() ) { // Create multi-dim klass object and link them together klassOop new_klass = objArrayKlassKlass::cast(Universe::objArrayKlassKlassObj())-> allocate_objArray_klass(dimension + 1, this_oop, CHECK_NULL); ak = objArrayKlassHandle(THREAD, new_klass); ak->set_lower_dimension(this_oop()); OrderAccess::storestore(); this_oop->set_higher_dimension(ak()); assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass"); } } } else { CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); } if (or_null) { return ak->array_klass_or_null(n); } return ak->array_klass(n, CHECK_NULL); } klassOop objArrayKlass::array_klass_impl(bool or_null, TRAPS) { return array_klass_impl(or_null, dimension() + 1, CHECK_NULL); } bool objArrayKlass::can_be_primary_super_slow() const { if (!bottom_klass()->klass_part()->can_be_primary_super()) // array of interfaces return false; else return Klass::can_be_primary_super_slow(); } objArrayOop objArrayKlass::compute_secondary_supers(int num_extra_slots, TRAPS) { // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... }; objArrayOop es = Klass::cast(element_klass())->secondary_supers(); objArrayHandle elem_supers (THREAD, es); int num_elem_supers = elem_supers.is_null() ? 0 : elem_supers->length(); int num_secondaries = num_extra_slots + 2 + num_elem_supers; if (num_secondaries == 2) { // Must share this for correct bootstrapping! return Universe::the_array_interfaces_array(); } else { objArrayOop sec_oop = oopFactory::new_system_objArray(num_secondaries, CHECK_NULL); objArrayHandle secondaries(THREAD, sec_oop); secondaries->obj_at_put(num_extra_slots+0, SystemDictionary::Cloneable_klass()); secondaries->obj_at_put(num_extra_slots+1, SystemDictionary::Serializable_klass()); for (int i = 0; i < num_elem_supers; i++) { klassOop elem_super = (klassOop) elem_supers->obj_at(i); klassOop array_super = elem_super->klass_part()->array_klass_or_null(); assert(array_super != NULL, "must already have been created"); secondaries->obj_at_put(num_extra_slots+2+i, array_super); } return secondaries(); } } bool objArrayKlass::compute_is_subtype_of(klassOop k) { if (!k->klass_part()->oop_is_objArray()) return arrayKlass::compute_is_subtype_of(k); objArrayKlass* oak = objArrayKlass::cast(k); return element_klass()->klass_part()->is_subtype_of(oak->element_klass()); } void objArrayKlass::initialize(TRAPS) { Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either instanceKlass or typeArrayKlass } #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \ { \ T* p = (T*)(a)->base(); \ T* const end = p + (a)->length(); \ while (p < end) { \ do_oop; \ p++; \ } \ } #define ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(T, a, p, low, high, do_oop) \ { \ T* const l = (T*)(low); \ T* const h = (T*)(high); \ T* p = (T*)(a)->base(); \ T* end = p + (a)->length(); \ if (p < l) p = l; \ if (end > h) end = h; \ while (p < end) { \ do_oop; \ ++p; \ } \ } #define ObjArrayKlass_OOP_ITERATE(a, p, do_oop) \ if (UseCompressedOops) { \ ObjArrayKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \ a, p, do_oop) \ } else { \ ObjArrayKlass_SPECIALIZED_OOP_ITERATE(oop, \ a, p, do_oop) \ } #define ObjArrayKlass_BOUNDED_OOP_ITERATE(a, p, low, high, do_oop) \ if (UseCompressedOops) { \ ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ a, p, low, high, do_oop) \ } else { \ ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ a, p, low, high, do_oop) \ } void objArrayKlass::oop_follow_contents(oop obj) { assert (obj->is_array(), "obj must be array"); objArrayOop(obj)->follow_header(); if (UseCompressedOops) { objarray_follow_contents<narrowOop>(obj, 0); } else { objarray_follow_contents<oop>(obj, 0); } } #ifndef SERIALGC void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { assert(obj->is_array(), "obj must be array"); objArrayOop(obj)->follow_header(cm); if (UseCompressedOops) { objarray_follow_contents<narrowOop>(cm, obj, 0); } else { objarray_follow_contents<oop>(cm, obj, 0); } } #endif // SERIALGC #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ \ int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \ OopClosureType* closure) { \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ assert (obj->is_array(), "obj must be array"); \ objArrayOop a = objArrayOop(obj); \ /* Get size before changing pointers. */ \ /* Don't call size() or oop_size() since that is a virtual call. */ \ int size = a->object_size(); \ if (closure->do_header()) { \ a->oop_iterate_header(closure); \ } \ ObjArrayKlass_OOP_ITERATE(a, p, (closure)->do_oop##nv_suffix(p)) \ return size; \ } #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ \ int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \ OopClosureType* closure, \ MemRegion mr) { \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ assert(obj->is_array(), "obj must be array"); \ objArrayOop a = objArrayOop(obj); \ /* Get size before changing pointers. */ \ /* Don't call size() or oop_size() since that is a virtual call */ \ int size = a->object_size(); \ if (closure->do_header()) { \ a->oop_iterate_header(closure, mr); \ } \ ObjArrayKlass_BOUNDED_OOP_ITERATE( \ a, p, mr.start(), mr.end(), (closure)->do_oop##nv_suffix(p)) \ return size; \ } // Like oop_oop_iterate but only iterates over a specified range and only used // for objArrayOops. #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \ \ int objArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \ OopClosureType* closure, \ int start, int end) { \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \ assert(obj->is_array(), "obj must be array"); \ objArrayOop a = objArrayOop(obj); \ /* Get size before changing pointers. */ \ /* Don't call size() or oop_size() since that is a virtual call */ \ int size = a->object_size(); \ if (UseCompressedOops) { \ HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<narrowOop>(start);\ /* this might be wierd if end needs to be aligned on HeapWord boundary */ \ HeapWord* high = (HeapWord*)((narrowOop*)a->base() + end); \ MemRegion mr(low, high); \ if (closure->do_header()) { \ a->oop_iterate_header(closure, mr); \ } \ ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ } else { \ HeapWord* low = start == 0 ? (HeapWord*)a : (HeapWord*)a->obj_at_addr<oop>(start); \ HeapWord* high = (HeapWord*)((oop*)a->base() + end); \ MemRegion mr(low, high); \ if (closure->do_header()) { \ a->oop_iterate_header(closure, mr); \ } \ ObjArrayKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ a, p, low, high, (closure)->do_oop##nv_suffix(p)) \ } \ return size; \ } ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN) ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN) ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m) ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r) int objArrayKlass::oop_adjust_pointers(oop obj) { assert(obj->is_objArray(), "obj must be obj array"); objArrayOop a = objArrayOop(obj); // Get size before changing pointers. // Don't call size() or oop_size() since that is a virtual call. int size = a->object_size(); a->adjust_header(); ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p)) return size; } #ifndef SERIALGC void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { assert(obj->is_objArray(), "obj must be obj array"); ObjArrayKlass_OOP_ITERATE( \ objArrayOop(obj), p, \ if (PSScavenge::should_scavenge(p)) { \ pm->claim_or_forward_depth(p); \ }) } int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { assert (obj->is_objArray(), "obj must be obj array"); objArrayOop a = objArrayOop(obj); ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p)) return a->object_size(); } int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj, HeapWord* beg_addr, HeapWord* end_addr) { assert (obj->is_objArray(), "obj must be obj array"); objArrayOop a = objArrayOop(obj); ObjArrayKlass_BOUNDED_OOP_ITERATE( \ a, p, beg_addr, end_addr, \ PSParallelCompact::adjust_pointer(p)) return a->object_size(); } #endif // SERIALGC // JVM support jint objArrayKlass::compute_modifier_flags(TRAPS) const { // The modifier for an objectArray is the same as its element if (element_klass() == NULL) { assert(Universe::is_bootstrapping(), "partial objArray only at startup"); return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; } // Return the flags of the bottom element type. jint element_flags = Klass::cast(bottom_klass())->compute_modifier_flags(CHECK_0); return (element_flags & (JVM_ACC_PUBLIC | JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) | (JVM_ACC_ABSTRACT | JVM_ACC_FINAL); } #ifndef PRODUCT // Printing void objArrayKlass::oop_print_on(oop obj, outputStream* st) { arrayKlass::oop_print_on(obj, st); assert(obj->is_objArray(), "must be objArray"); objArrayOop oa = objArrayOop(obj); int print_len = MIN2((intx) oa->length(), MaxElementPrintSize); for(int index = 0; index < print_len; index++) { st->print(" - %3d : ", index); oa->obj_at(index)->print_value_on(st); st->cr(); } int remaining = oa->length() - print_len; if (remaining > 0) { tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); } } #endif //PRODUCT static int max_objArray_print_length = 4; void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) { assert(obj->is_objArray(), "must be objArray"); st->print("a "); element_klass()->print_value_on(st); int len = objArrayOop(obj)->length(); st->print("[%d] ", len); obj->print_address_on(st); if (NOT_PRODUCT(PrintOopAddress ||) PrintMiscellaneous && (WizardMode || Verbose)) { st->print("{"); for (int i = 0; i < len; i++) { if (i > max_objArray_print_length) { st->print("..."); break; } st->print(" "INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i)); } st->print(" }"); } } const char* objArrayKlass::internal_name() const { return external_name(); } // Verification void objArrayKlass::oop_verify_on(oop obj, outputStream* st) { arrayKlass::oop_verify_on(obj, st); guarantee(obj->is_objArray(), "must be objArray"); objArrayOop oa = objArrayOop(obj); for(int index = 0; index < oa->length(); index++) { guarantee(oa->obj_at(index)->is_oop_or_null(), "should be oop"); } } void objArrayKlass::oop_verify_old_oop(oop obj, oop* p, bool allow_dirty) { /* $$$ move into remembered set verification? RememberedSet::verify_old_oop(obj, p, allow_dirty, true); */ } void objArrayKlass::oop_verify_old_oop(oop obj, narrowOop* p, bool allow_dirty) {}