/* * Copyright (c) 2001, 2013, 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_MEMORY_SPECIALIZED_OOP_CLOSURES_HPP #define SHARE_VM_MEMORY_SPECIALIZED_OOP_CLOSURES_HPP #include "utilities/macros.hpp" #include "utilities/templateIdioms.hpp" #if INCLUDE_ALL_GCS #include "gc_implementation/g1/g1_specialized_oop_closures.hpp" #endif // INCLUDE_ALL_GCS // The following OopClosure types get specialized versions of // "oop_oop_iterate" that invoke the closures' do_oop methods // non-virtually, using a mechanism defined in this file. Extend these // macros in the obvious way to add specializations for new closures. // Forward declarations. class OopClosure; class OopsInGenClosure; // DefNew class ScanClosure; class FastScanClosure; class FilteringClosure; // ParNew class ParScanWithBarrierClosure; class ParScanWithoutBarrierClosure; // CMS class MarkRefsIntoAndScanClosure; class Par_MarkRefsIntoAndScanClosure; class PushAndMarkClosure; class Par_PushAndMarkClosure; class PushOrMarkClosure; class Par_PushOrMarkClosure; class CMSKeepAliveClosure; class CMSInnerParMarkAndPushClosure; // Misc class NoHeaderExtendedOopClosure; // This macro applies an argument macro to all OopClosures for which we // want specialized bodies of "oop_oop_iterate". The arguments to "f" are: // "f(closureType, non_virtual)" // where "closureType" is the name of the particular subclass of OopClosure, // and "non_virtual" will be the string "_nv" if the closure type should // have its "do_oop" method invoked non-virtually, or else the // string "_v". ("OopClosure" itself will be the only class in the latter // category.) // This is split into several because of a Visual C++ 6.0 compiler bug // where very long macros cause the compiler to crash // These two macros are for explicitly declaring base classes for closures that // have no do_oop implementation and hence need virtual calls. // It should never be necessary to add more closure types except the base // classes here as auto specialization mechanism automatically // checks that the declared closure type also has its own declaration // of the specialized calls. #define UNSPECIALIZED_OOP_OOP_ITERATE_CLOSURES(f) \ f(ExtendedOopClosure) \ f(OopClosure) #define UNSPECIALIZED_DO_METADATA_CLOSURES(f) \ f(ExtendedOopClosure) #define FORWARD_DECLARE_CLOSURE(OopClosureType) \ class OopClosureType; UNSPECIALIZED_OOP_OOP_ITERATE_CLOSURES(FORWARD_DECLARE_CLOSURE) UNSPECIALIZED_DO_METADATA_CLOSURES(FORWARD_DECLARE_CLOSURE) // Some other heap might define further specialized closures. #ifndef FURTHER_SPECIALIZED_OOP_OOP_ITERATE_CLOSURES #define FURTHER_SPECIALIZED_OOP_OOP_ITERATE_CLOSURES(f) \ /* None */ #endif #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_S(f) \ f(ScanClosure,_nv) \ f(FastScanClosure,_nv) \ f(FilteringClosure,_nv) #if INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f) \ f(ParScanWithBarrierClosure,_nv) \ f(ParScanWithoutBarrierClosure,_nv) #else // INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f) #endif // INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(f) \ f(NoHeaderExtendedOopClosure,_nv) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_S(f) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f) #if INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) \ f(MarkRefsIntoAndScanClosure,_nv) \ f(Par_MarkRefsIntoAndScanClosure,_nv) \ f(PushAndMarkClosure,_nv) \ f(Par_PushAndMarkClosure,_nv) \ f(PushOrMarkClosure,_nv) \ f(Par_PushOrMarkClosure,_nv) \ f(CMSKeepAliveClosure,_nv) \ f(CMSInnerParMarkAndPushClosure,_nv) \ FURTHER_SPECIALIZED_OOP_OOP_ITERATE_CLOSURES(f) #else // INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) #endif // INCLUDE_ALL_GCS // We separate these out, because sometime the general one has // a different definition from the specialized ones, and sometimes it // doesn't. #define ALL_OOP_OOP_ITERATE_CLOSURES_1(f) \ f(ExtendedOopClosure,_v) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(f) #define ALL_OOP_OOP_ITERATE_CLOSURES_2(f) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) #if INCLUDE_ALL_GCS // This macro applies an argument macro to all OopClosures for which we // want specialized bodies of a family of methods related to // "par_oop_iterate". The arguments to f are the same as above. // The "root_class" is the most general class to define; this may be // "OopClosure" in some applications and "OopsInGenClosure" in others. #define SPECIALIZED_PAR_OOP_ITERATE_CLOSURES(f) \ f(MarkRefsIntoAndScanClosure,_nv) \ f(PushAndMarkClosure,_nv) \ f(Par_MarkRefsIntoAndScanClosure,_nv) \ f(Par_PushAndMarkClosure,_nv) #define ALL_PAR_OOP_ITERATE_CLOSURES(f) \ f(ExtendedOopClosure,_v) \ SPECIALIZED_PAR_OOP_ITERATE_CLOSURES(f) #endif // INCLUDE_ALL_GCS // This macro applies an argument macro to all OopClosures for which we // want specialized bodies of a family of methods related to // "oops_since_save_marks_do". The arguments to f are the same as above. // The "root_class" is the most general class to define; this may be // "OopClosure" in some applications and "OopsInGenClosure" in others. // Some other heap might define further specialized closures. #ifndef FURTHER_SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES #define FURTHER_SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(f) \ /* None */ #endif #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_S(f) \ f(ScanClosure,_nv) \ f(FastScanClosure,_nv) #if INCLUDE_ALL_GCS #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_P(f) \ f(ParScanWithBarrierClosure,_nv) \ f(ParScanWithoutBarrierClosure,_nv) \ FURTHER_SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(f) #else // INCLUDE_ALL_GCS #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_P(f) #endif // INCLUDE_ALL_GCS #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG(f) \ SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_S(f) \ SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_P(f) #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(f) \ SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG(f) // We separate these out, because sometime the general one has // a different definition from the specialized ones, and sometimes it // doesn't. // NOTE: One of the valid criticisms of this // specialize-oop_oop_iterate-for-specific-closures idiom is that it is // easy to have a silent performance bug: if you fail to de-virtualize, // things still work, just slower. The "SpecializationStats" mode is // intended to at least make such a failure easy to detect. // *Not* using the ALL_SINCE_SAVE_MARKS_CLOSURES(f) macro defined // below means that *only* closures for which oop_oop_iterate specializations // exist above may be applied to "oops_since_save_marks". That is, // this form of the performance bug is caught statically. When you add // a definition for the general type, this property goes away. // Make sure you test with SpecializationStats to find such bugs // when introducing a new closure where you don't want virtual dispatch. #define ALL_SINCE_SAVE_MARKS_CLOSURES(f) \ f(OopsInGenClosure,_v) \ SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(f) // For keeping stats on effectiveness. #define ENABLE_SPECIALIZATION_STATS 0 enum DispatchTag { _unknown_klass = 1, _instance_mirror_klass, _instance_class_loader_klass, _instance_ref_klass, }; /** * The OopClosureDispatcher is a proxy class that automatically figures out * which OopClosure member function to call. It first checks for overridden * specializations using macros (only needed for OopClosure and * ExtendedOopClosure. These will result in virtual calls. * Otherwise if it's a subclass of these two, it will first try to call * the corresponding _nv member function for backward compatibility. * Otherwise, it will check for a a normal non nv declaration, in the derived * class (not the super class). If it exists, it will be called, otherwise * it resorts to a normal virtual call. */ class OopClosureDispatcher : AllStatic { template static typename enable_if::value, void>::type do_oop_internal_try_nv(OopClosureType *cl, OopType *obj); template static typename enable_if::value, void>::type do_oop_internal_try_nv(OopClosureType *cl, OopType *obj); template static typename enable_if::value, void>::type do_oop_internal_try_v(OopClosureType *cl, OopType *obj); template static typename enable_if::value, void>::type do_oop_internal_try_v(OopClosureType *cl, OopType *obj); template static typename enable_if::value, bool>::type do_metadata_internal_try_nv(OopClosureType *cl); template static typename enable_if::value, bool>::type do_metadata_internal_try_nv(OopClosureType *cl); template static typename enable_if::value, bool>::type do_metadata_internal_try_v(OopClosureType *cl); template static typename enable_if::value, bool>::type do_metadata_internal_try_v(OopClosureType *cl); template static typename enable_if::value, void>::type do_klass_internal_try_nv(OopClosureType *cl, Klass *klass); template static typename enable_if::value, void>::type do_klass_internal_try_nv(OopClosureType *cl, Klass *klass); template static typename enable_if::value, void>::type do_klass_internal_try_v(OopClosureType *cl, Klass *klass); template static typename enable_if::value, void>::type do_klass_internal_try_v(OopClosureType *cl, Klass *klass); template static typename enable_if::value, void>::type do_class_loader_data_internal_try_nv(OopClosureType *cl, ClassLoaderData *cld); template static typename enable_if::value, void>::type do_class_loader_data_internal_try_nv(OopClosureType *cl, ClassLoaderData *cld); template static typename enable_if::value, void>::type do_class_loader_data_internal_try_v(OopClosureType *cl, ClassLoaderData *cld); template static typename enable_if::value, void>::type do_class_loader_data_internal_try_v(OopClosureType *cl, ClassLoaderData *cld); template static void do_oop_internal(OopClosureType *cl, OopType *obj); template static bool do_metadata_internal(OopClosureType *cl); template static void do_klass_internal(OopClosureType *cl, Klass *klass); template static void do_class_loader_data_internal(OopClosureType *cl, ClassLoaderData *cld); public: // Make sure we only dispatch to OopClosure subtypes, otherwise compiler error template static typename enable_if::value, void>::type do_oop(OopClosureType *cl, OopType *obj); // Only do metadata stuff on ExtendedOopClosure, otherwise compiler error template static typename enable_if::value, bool>::type do_metadata(OopClosureType *cl); template static typename enable_if::value, void>::type do_klass(OopClosureType *cl, Klass *klass); template static typename enable_if::value, void>::type do_class_loader_data(OopClosureType *cl, ClassLoaderData* cld); }; class SpecializationStats { public: enum Kind { ik, // InstanceKlass irk, // InstanceRefKlass oa, // ObjArrayKlass NUM_Kinds }; #if ENABLE_SPECIALIZATION_STATS private: static bool _init; static bool _wrapped; static jint _numCallsAll; static jint _numCallsTotal[NUM_Kinds]; static jint _numCalls_nv[NUM_Kinds]; static jint _numDoOopCallsTotal[NUM_Kinds]; static jint _numDoOopCalls_nv[NUM_Kinds]; public: #endif static void clear() PRODUCT_RETURN; static inline void record_call() PRODUCT_RETURN; static inline void record_iterate_call_v(Kind k) PRODUCT_RETURN; static inline void record_iterate_call_nv(Kind k) PRODUCT_RETURN; static inline void record_do_oop_call_v(Kind k) PRODUCT_RETURN; static inline void record_do_oop_call_nv(Kind k) PRODUCT_RETURN; static void print() PRODUCT_RETURN; }; #ifndef PRODUCT #if ENABLE_SPECIALIZATION_STATS inline void SpecializationStats::record_call() { Atomic::inc(&_numCallsAll); } inline void SpecializationStats::record_iterate_call_v(Kind k) { Atomic::inc(&_numCallsTotal[k]); } inline void SpecializationStats::record_iterate_call_nv(Kind k) { Atomic::inc(&_numCallsTotal[k]); Atomic::inc(&_numCalls_nv[k]); } inline void SpecializationStats::record_do_oop_call_v(Kind k) { Atomic::inc(&_numDoOopCallsTotal[k]); } inline void SpecializationStats::record_do_oop_call_nv(Kind k) { Atomic::inc(&_numDoOopCallsTotal[k]); Atomic::inc(&_numDoOopCalls_nv[k]); } #else // !ENABLE_SPECIALIZATION_STATS inline void SpecializationStats::record_call() {} inline void SpecializationStats::record_iterate_call_v(Kind k) {} inline void SpecializationStats::record_iterate_call_nv(Kind k) {} inline void SpecializationStats::record_do_oop_call_v(Kind k) {} inline void SpecializationStats::record_do_oop_call_nv(Kind k) {} inline void SpecializationStats::clear() {} inline void SpecializationStats::print() {} #endif // ENABLE_SPECIALIZATION_STATS #endif // !PRODUCT #endif // SHARE_VM_MEMORY_SPECIALIZED_OOP_CLOSURES_HPP