Mercurial > hg > graal-compiler
view src/share/vm/ci/ciField.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 | f95d63e2154a |
children | 06f017f7daa7 3582bf76420e |
line wrap: on
line source
/* * Copyright (c) 1999, 2010, 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 "ci/ciField.hpp" #include "ci/ciInstanceKlass.hpp" #include "ci/ciUtilities.hpp" #include "classfile/systemDictionary.hpp" #include "gc_interface/collectedHeap.inline.hpp" #include "interpreter/linkResolver.hpp" #include "memory/universe.inline.hpp" #include "oops/oop.inline.hpp" #include "oops/oop.inline2.hpp" #include "runtime/fieldDescriptor.hpp" // ciField // // This class represents the result of a field lookup in the VM. // The lookup may not succeed, in which case the information in // the ciField will be incomplete. // The ciObjectFactory cannot create circular data structures in one query. // To avoid vicious circularities, we initialize ciField::_type to NULL // for reference types and derive it lazily from the ciField::_signature. // Primitive types are eagerly initialized, and basic layout queries // can succeed without initialization, using only the BasicType of the field. // Notes on bootstrapping and shared CI objects: A field is shared if and // only if it is (a) non-static and (b) declared by a shared instance klass. // This allows non-static field lists to be cached on shared types. // Because the _type field is lazily initialized, however, there is a // special restriction that a shared field cannot cache an unshared type. // This puts a small performance penalty on shared fields with unshared // types, such as StackTraceElement[] Throwable.stackTrace. // (Throwable is shared because ClassCastException is shared, but // StackTraceElement is not presently shared.) // It is not a vicious circularity for a ciField to recursively create // the ciSymbols necessary to represent its name and signature. // Therefore, these items are created eagerly, and the name and signature // of a shared field are themselves shared symbols. This somewhat // pollutes the set of shared CI objects: It grows from 50 to 93 items, // with all of the additional 43 being uninteresting shared ciSymbols. // This adds at most one step to the binary search, an amount which // decreases for complex compilation tasks. // ------------------------------------------------------------------ // ciField::ciField ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with(NULL) { ASSERT_IN_VM; CompilerThread *thread = CompilerThread::current(); assert(ciObjectFactory::is_initialized(), "not a shared field"); assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool"); _cp_index = index; constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants()); // Get the field's name, signature, and type. symbolHandle name (thread, cpool->name_ref_at(index)); _name = ciEnv::current(thread)->get_object(name())->as_symbol(); int nt_index = cpool->name_and_type_ref_index_at(index); int sig_index = cpool->signature_ref_index_at(nt_index); symbolHandle signature (thread, cpool->symbol_at(sig_index)); _signature = ciEnv::current(thread)->get_object(signature())->as_symbol(); BasicType field_type = FieldType::basic_type(signature()); // If the field is a pointer type, get the klass of the // field. if (field_type == T_OBJECT || field_type == T_ARRAY) { bool ignore; // This is not really a class reference; the index always refers to the // field's type signature, as a symbol. Linkage checks do not apply. _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass); } else { _type = ciType::make(field_type); } _name = (ciSymbol*)ciEnv::current(thread)->get_object(name()); // Get the field's declared holder. // // Note: we actually create a ciInstanceKlass for this klass, // even though we may not need to. int holder_index = cpool->klass_ref_index_at(index); bool holder_is_accessible; ciInstanceKlass* declared_holder = ciEnv::current(thread)->get_klass_by_index(cpool, holder_index, holder_is_accessible, klass)->as_instance_klass(); // The declared holder of this field may not have been loaded. // Bail out with partial field information. if (!holder_is_accessible) { // _cp_index and _type have already been set. // The default values for _flags and _constant_value will suffice. // We need values for _holder, _offset, and _is_constant, _holder = declared_holder; _offset = -1; _is_constant = false; return; } instanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass(); // Perform the field lookup. fieldDescriptor field_desc; klassOop canonical_holder = loaded_decl_holder->find_field(name(), signature(), &field_desc); if (canonical_holder == NULL) { // Field lookup failed. Will be detected by will_link. _holder = declared_holder; _offset = -1; _is_constant = false; return; } assert(canonical_holder == field_desc.field_holder(), "just checking"); initialize_from(&field_desc); } ciField::ciField(fieldDescriptor *fd): _known_to_link_with(NULL) { ASSERT_IN_VM; _cp_index = -1; // Get the field's name, signature, and type. ciEnv* env = CURRENT_ENV; _name = env->get_object(fd->name())->as_symbol(); _signature = env->get_object(fd->signature())->as_symbol(); BasicType field_type = fd->field_type(); // If the field is a pointer type, get the klass of the // field. if (field_type == T_OBJECT || field_type == T_ARRAY) { _type = NULL; // must call compute_type on first access } else { _type = ciType::make(field_type); } initialize_from(fd); // Either (a) it is marked shared, or else (b) we are done bootstrapping. assert(is_shared() || ciObjectFactory::is_initialized(), "bootstrap classes must not create & cache unshared fields"); } static bool trust_final_non_static_fields(ciInstanceKlass* holder) { if (holder == NULL) return false; if (holder->name() == ciSymbol::java_lang_System()) // Never trust strangely unstable finals: System.out, etc. return false; // Even if general trusting is disabled, trust system-built closures in these packages. if (holder->is_in_package("java/dyn") || holder->is_in_package("sun/dyn")) return true; return TrustFinalNonStaticFields; } void ciField::initialize_from(fieldDescriptor* fd) { // Get the flags, offset, and canonical holder of the field. _flags = ciFlags(fd->access_flags()); _offset = fd->offset(); _holder = CURRENT_ENV->get_object(fd->field_holder())->as_instance_klass(); // Check to see if the field is constant. if (_holder->is_initialized() && this->is_final()) { if (!this->is_static()) { // A field can be constant if it's a final static field or if it's // a final non-static field of a trusted class ({java,sun}.dyn). if (trust_final_non_static_fields(_holder)) { _is_constant = true; return; } _is_constant = false; return; } // This field just may be constant. The only cases where it will // not be constant are: // // 1. The field holds a non-perm-space oop. The field is, strictly // speaking, constant but we cannot embed non-perm-space oops into // generated code. For the time being we need to consider the // field to be not constant. // 2. The field is a *special* static&final field whose value // may change. The three examples are java.lang.System.in, // java.lang.System.out, and java.lang.System.err. klassOop k = _holder->get_klassOop(); assert( SystemDictionary::System_klass() != NULL, "Check once per vm"); if( k == SystemDictionary::System_klass() ) { // Check offsets for case 2: System.in, System.out, or System.err if( _offset == java_lang_System::in_offset_in_bytes() || _offset == java_lang_System::out_offset_in_bytes() || _offset == java_lang_System::err_offset_in_bytes() ) { _is_constant = false; return; } } _is_constant = true; switch(type()->basic_type()) { case T_BYTE: _constant_value = ciConstant(type()->basic_type(), k->byte_field(_offset)); break; case T_CHAR: _constant_value = ciConstant(type()->basic_type(), k->char_field(_offset)); break; case T_SHORT: _constant_value = ciConstant(type()->basic_type(), k->short_field(_offset)); break; case T_BOOLEAN: _constant_value = ciConstant(type()->basic_type(), k->bool_field(_offset)); break; case T_INT: _constant_value = ciConstant(type()->basic_type(), k->int_field(_offset)); break; case T_FLOAT: _constant_value = ciConstant(k->float_field(_offset)); break; case T_DOUBLE: _constant_value = ciConstant(k->double_field(_offset)); break; case T_LONG: _constant_value = ciConstant(k->long_field(_offset)); break; case T_OBJECT: case T_ARRAY: { oop o = k->obj_field(_offset); // A field will be "constant" if it is known always to be // a non-null reference to an instance of a particular class, // or to a particular array. This can happen even if the instance // or array is not perm. In such a case, an "unloaded" ciArray // or ciInstance is created. The compiler may be able to use // information about the object's class (which is exact) or length. if (o == NULL) { _constant_value = ciConstant(type()->basic_type(), ciNullObject::make()); } else { _constant_value = ciConstant(type()->basic_type(), CURRENT_ENV->get_object(o)); assert(_constant_value.as_object() == CURRENT_ENV->get_object(o), "check interning"); } } } } else { _is_constant = false; } } // ------------------------------------------------------------------ // ciField::compute_type // // Lazily compute the type, if it is an instance klass. ciType* ciField::compute_type() { GUARDED_VM_ENTRY(return compute_type_impl();) } ciType* ciField::compute_type_impl() { ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, _signature, false); if (!type->is_primitive_type() && is_shared()) { // We must not cache a pointer to an unshared type, in a shared field. bool type_is_also_shared = false; if (type->is_type_array_klass()) { type_is_also_shared = true; // int[] etc. are explicitly bootstrapped } else if (type->is_instance_klass()) { type_is_also_shared = type->as_instance_klass()->is_shared(); } else { // Currently there is no 'shared' query for array types. type_is_also_shared = !ciObjectFactory::is_initialized(); } if (!type_is_also_shared) return type; // Bummer. } _type = type; return type; } // ------------------------------------------------------------------ // ciField::will_link // // Can a specific access to this field be made without causing // link errors? bool ciField::will_link(ciInstanceKlass* accessing_klass, Bytecodes::Code bc) { VM_ENTRY_MARK; if (_offset == -1) { // at creation we couldn't link to our holder so we need to // maintain that stance, otherwise there's no safe way to use this // ciField. return false; } if (_known_to_link_with == accessing_klass) { return true; } FieldAccessInfo result; constantPoolHandle c_pool(THREAD, accessing_klass->get_instanceKlass()->constants()); LinkResolver::resolve_field(result, c_pool, _cp_index, Bytecodes::java_code(bc), true, false, KILL_COMPILE_ON_FATAL_(false)); // update the hit-cache, unless there is a problem with memory scoping: if (accessing_klass->is_shared() || !is_shared()) _known_to_link_with = accessing_klass; return true; } // ------------------------------------------------------------------ // ciField::print void ciField::print() { tty->print("<ciField "); _holder->print_name(); tty->print("."); _name->print_symbol(); tty->print(" offset=%d type=", _offset); if (_type != NULL) _type->print_name(); else tty->print("(reference)"); tty->print(" is_constant=%s", bool_to_str(_is_constant)); if (_is_constant && is_static()) { tty->print(" constant_value="); _constant_value.print(); } tty->print(">"); } // ------------------------------------------------------------------ // ciField::print_name_on // // Print the name of this field void ciField::print_name_on(outputStream* st) { name()->print_symbol_on(st); }