Mercurial > hg > graal-compiler
view src/share/vm/ci/ciInstanceKlass.hpp @ 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 49036505ab5f |
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. * */ #ifndef SHARE_VM_CI_CIINSTANCEKLASS_HPP #define SHARE_VM_CI_CIINSTANCEKLASS_HPP #include "ci/ciConstantPoolCache.hpp" #include "ci/ciFlags.hpp" #include "ci/ciInstanceKlassKlass.hpp" #include "ci/ciKlass.hpp" #include "ci/ciSymbol.hpp" // ciInstanceKlass // // This class represents a klassOop in the HotSpot virtual machine // whose Klass part is an instanceKlass. It may or may not // be loaded. class ciInstanceKlass : public ciKlass { CI_PACKAGE_ACCESS friend class ciBytecodeStream; friend class ciEnv; friend class ciExceptionHandler; friend class ciMethod; friend class ciField; private: jobject _loader; jobject _protection_domain; instanceKlass::ClassState _init_state; // state of class bool _is_shared; bool _has_finalizer; bool _has_subklass; bool _has_nonstatic_fields; ciFlags _flags; jint _nonstatic_field_size; jint _nonstatic_oop_map_size; // Lazy fields get filled in only upon request. ciInstanceKlass* _super; ciInstance* _java_mirror; ciConstantPoolCache* _field_cache; // cached map index->field GrowableArray<ciField*>* _nonstatic_fields; enum { implementors_limit = instanceKlass::implementors_limit }; ciInstanceKlass* _implementors[implementors_limit]; jint _nof_implementors; GrowableArray<ciField*>* _non_static_fields; protected: ciInstanceKlass(KlassHandle h_k); ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain); instanceKlass* get_instanceKlass() const { return (instanceKlass*)get_Klass(); } oop loader(); jobject loader_handle(); oop protection_domain(); jobject protection_domain_handle(); const char* type_string() { return "ciInstanceKlass"; } bool is_in_package_impl(const char* packagename, int len); void print_impl(outputStream* st); ciConstantPoolCache* field_cache(); bool is_shared() { return _is_shared; } void compute_shared_init_state(); bool compute_shared_has_subklass(); int compute_shared_nof_implementors(); int compute_nonstatic_fields(); GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields); // Update the init_state for shared klasses void update_if_shared(instanceKlass::ClassState expected) { if (_is_shared && _init_state != expected) { if (is_loaded()) compute_shared_init_state(); } } public: // Has this klass been initialized? bool is_initialized() { update_if_shared(instanceKlass::fully_initialized); return _init_state == instanceKlass::fully_initialized; } // Is this klass being initialized? bool is_being_initialized() { update_if_shared(instanceKlass::being_initialized); return _init_state == instanceKlass::being_initialized; } // Has this klass been linked? bool is_linked() { update_if_shared(instanceKlass::linked); return _init_state >= instanceKlass::linked; } // General klass information. ciFlags flags() { assert(is_loaded(), "must be loaded"); return _flags; } bool has_finalizer() { assert(is_loaded(), "must be loaded"); return _has_finalizer; } bool has_subklass() { assert(is_loaded(), "must be loaded"); if (_is_shared && !_has_subklass) { if (flags().is_final()) { return false; } else { return compute_shared_has_subklass(); } } return _has_subklass; } jint size_helper() { return (Klass::layout_helper_size_in_bytes(layout_helper()) >> LogHeapWordSize); } jint nonstatic_field_size() { assert(is_loaded(), "must be loaded"); return _nonstatic_field_size; } jint has_nonstatic_fields() { assert(is_loaded(), "must be loaded"); return _has_nonstatic_fields; } jint nonstatic_oop_map_size() { assert(is_loaded(), "must be loaded"); return _nonstatic_oop_map_size; } ciInstanceKlass* super(); jint nof_implementors() { assert(is_loaded(), "must be loaded"); if (_is_shared) return compute_shared_nof_implementors(); return _nof_implementors; } ciInstanceKlass* get_canonical_holder(int offset); ciField* get_field_by_offset(int field_offset, bool is_static); ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static); GrowableArray<ciField*>* non_static_fields(); // total number of nonstatic fields (including inherited): int nof_nonstatic_fields() { if (_nonstatic_fields == NULL) return compute_nonstatic_fields(); else return _nonstatic_fields->length(); } // nth nonstatic field (presented by ascending address) ciField* nonstatic_field_at(int i) { assert(_nonstatic_fields != NULL, ""); return _nonstatic_fields->at(i); } ciInstanceKlass* unique_concrete_subklass(); bool has_finalizable_subclass(); bool contains_field_offset(int offset) { return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size()); } // Get the instance of java.lang.Class corresponding to // this klass. This instance is used for locking of // synchronized static methods of this klass. ciInstance* java_mirror(); // Java access flags bool is_public () { return flags().is_public(); } bool is_final () { return flags().is_final(); } bool is_super () { return flags().is_super(); } bool is_interface () { return flags().is_interface(); } bool is_abstract () { return flags().is_abstract(); } ciMethod* find_method(ciSymbol* name, ciSymbol* signature); // Note: To find a method from name and type strings, use ciSymbol::make, // but consider adding to vmSymbols.hpp instead. bool is_leaf_type(); ciInstanceKlass* implementor(int n); // Is the defining class loader of this class the default loader? bool uses_default_loader(); bool is_java_lang_Object(); // Is this klass in the given package? bool is_in_package(const char* packagename) { return is_in_package(packagename, (int) strlen(packagename)); } bool is_in_package(const char* packagename, int len); // What kind of ciObject is this? bool is_instance_klass() { return true; } bool is_java_klass() { return true; } }; #endif // SHARE_VM_CI_CIINSTANCEKLASS_HPP