/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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 "runtime/atomic.hpp"
#ifndef SERIALGC
#include "gc_implementation/g1/g1_specialized_oop_closures.hpp"
#endif
// 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 PushAndMarkClosure;
class Par_PushAndMarkClosure;
class PushOrMarkClosure;
class Par_PushOrMarkClosure;
class CMSKeepAliveClosure;
// 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
// Some other heap might define further specialized 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) \
#ifndef SERIALGC
#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f) \
#else // SERIALGC
#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f)
#endif // SERIALGC
#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(f) \
#ifndef SERIALGC
#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) \
f(PushAndMarkClosure,_nv) \
f(PushOrMarkClosure,_nv) \
f(Par_PushOrMarkClosure,_nv) \
f(CMSKeepAliveClosure,_nv) \
#else // SERIALGC
#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f)
#endif // SERIALGC
// 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(OopClosure,_v) \
#define ALL_OOP_OOP_ITERATE_CLOSURES_2(f) \
#ifndef SERIALGC
// 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(PushAndMarkClosure,_nv) \
#define ALL_PAR_OOP_ITERATE_CLOSURES(f) \
f(OopClosure,_v) \
#endif // SERIALGC
// 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.
#define FURTHER_SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(f) \
/* None */
#endif
#define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_S(f) \
f(ScanClosure,_nv) \
#ifndef SERIALGC
#define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_P(f) \
#else // SERIALGC
#endif // SERIALGC
#define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG(f) \
#define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(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) \
// For keeping stats on effectiveness.
#define ENABLE_SPECIALIZATION_STATS 0
class SpecializationStats {
public:
enum Kind {
};
private:
static bool _init;
static bool _wrapped;
public:
#endif
};
#ifndef PRODUCT
}
}
}
}
}
#else // !ENABLE_SPECIALIZATION_STATS
#endif // ENABLE_SPECIALIZATION_STATS
#endif // !PRODUCT
#endif // SHARE_VM_MEMORY_SPECIALIZED_OOP_CLOSURES_HPP