stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8231471: Obsolete -XX:CompilationPolicyChoice

Browse Source 
Reviewed-by: kvn, dholmes, thartmann
This commit is contained in:
Claes Redestad 2019-09-27 12:46:14 +02:00
parent e4314c158d
commit c127592320
7 changed files with 9 additions and 588 deletions

19
src/hotspot/share/compiler/compilerDefinitions.cpp

@ -188,14 +188,6 @@ void select_compilation_mode_ergonomically() {
#endif // TIERED
void CompilerConfig::set_tiered_flags() {
// With tiered, set default policy to SimpleThresholdPolicy, which is 2.
if (FLAG_IS_DEFAULT(CompilationPolicyChoice)) {
FLAG_SET_DEFAULT(CompilationPolicyChoice, 2);
}
if (CompilationPolicyChoice < 2) {
vm_exit_during_initialization(
"Incompatible compilation policy selected", NULL);
}
// Increase the code cache size - tiered compiles a lot more.
if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
FLAG_SET_ERGO(ReservedCodeCacheSize,
@ -420,17 +412,6 @@ void CompilerConfig::ergo_initialize() {
if (TieredCompilation) {
set_tiered_flags();
} else {
int max_compilation_policy_choice = 1;
#ifdef COMPILER2
if (is_server_compilation_mode_vm()) {
max_compilation_policy_choice = 2;
}
#endif
// Check if the policy is valid.
if (CompilationPolicyChoice >= max_compilation_policy_choice) {
vm_exit_during_initialization(
"Incompatible compilation policy selected", NULL);
}
// Scale CompileThreshold
// CompileThresholdScaling == 0.0 is equivalent to -Xint and leaves CompileThreshold unchanged.
if (!FLAG_IS_DEFAULT(CompileThresholdScaling) && CompileThresholdScaling > 0.0) {

2
src/hotspot/share/runtime/arguments.cpp

@ -526,7 +526,6 @@ static SpecialFlag const special_jvm_flags[] = {
{ "MinRAMFraction", JDK_Version::jdk(10), JDK_Version::undefined(), JDK_Version::undefined() },
{ "InitialRAMFraction", JDK_Version::jdk(10), JDK_Version::undefined(), JDK_Version::undefined() },
{ "UseMembar", JDK_Version::jdk(10), JDK_Version::jdk(12), JDK_Version::undefined() },
{ "CompilationPolicyChoice", JDK_Version::jdk(13), JDK_Version::jdk(14), JDK_Version::undefined() },
{ "AllowJNIEnvProxy", JDK_Version::jdk(13), JDK_Version::jdk(14), JDK_Version::jdk(15) },
{ "ThreadLocalHandshakes", JDK_Version::jdk(13), JDK_Version::jdk(14), JDK_Version::jdk(15) },
{ "AllowRedefinitionToAddDeleteMethods", JDK_Version::jdk(13), JDK_Version::undefined(), JDK_Version::undefined() },
@ -547,6 +546,7 @@ static SpecialFlag const special_jvm_flags[] = {
{ "SharedReadOnlySize", JDK_Version::undefined(), JDK_Version::jdk(10), JDK_Version::undefined() },
{ "SharedMiscDataSize", JDK_Version::undefined(), JDK_Version::jdk(10), JDK_Version::undefined() },
{ "SharedMiscCodeSize", JDK_Version::undefined(), JDK_Version::jdk(10), JDK_Version::undefined() },
{ "CompilationPolicyChoice", JDK_Version::jdk(13), JDK_Version::jdk(14), JDK_Version::jdk(15) },
{ "FailOverToOldVerifier", JDK_Version::undefined(), JDK_Version::jdk(14), JDK_Version::jdk(15) },
{ "BindGCTaskThreadsToCPUs", JDK_Version::undefined(), JDK_Version::jdk(14), JDK_Version::jdk(16) },
{ "UseGCTaskAffinity", JDK_Version::undefined(), JDK_Version::jdk(14), JDK_Version::jdk(16) },

234
src/hotspot/share/runtime/compilationPolicy.cpp

@ -36,7 +36,6 @@
#include "runtime/compilationPolicy.hpp"
#include "runtime/frame.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/rframe.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/thread.hpp"
#include "runtime/tieredThresholdPolicy.hpp"
@ -56,28 +55,16 @@ CompilationPolicy* CompilationPolicy::_policy;
// Determine compilation policy based on command line argument
void compilationPolicy_init() {
switch(CompilationPolicyChoice) {
case 0:
CompilationPolicy::set_policy(new SimpleCompPolicy());
break;
case 1:
#ifdef COMPILER2
CompilationPolicy::set_policy(new StackWalkCompPolicy());
#else
Unimplemented();
#endif
break;
case 2:
#ifdef TIERED
#ifdef TIERED
if (TieredCompilation) {
CompilationPolicy::set_policy(new TieredThresholdPolicy());
#else
Unimplemented();
#endif
break;
default:
fatal("CompilationPolicyChoice must be in the range: [0-2]");
} else {
CompilationPolicy::set_policy(new SimpleCompPolicy());
}
#else
CompilationPolicy::set_policy(new SimpleCompPolicy());
#endif
CompilationPolicy::policy()->initialize();
}
@ -519,208 +506,3 @@ void SimpleCompPolicy::method_back_branch_event(const methodHandle& m, int bci,
NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
}
}
// StackWalkCompPolicy - walk up stack to find a suitable method to compile
#ifdef COMPILER2
const char* StackWalkCompPolicy::_msg = NULL;
// Consider m for compilation
void StackWalkCompPolicy::method_invocation_event(const methodHandle& m, JavaThread* thread) {
const int comp_level = CompLevel_highest_tier;
const int hot_count = m->invocation_count();
reset_counter_for_invocation_event(m);
if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(m, comp_level)) {
ResourceMark rm(thread);
frame fr = thread->last_frame();
assert(fr.is_interpreted_frame(), "must be interpreted");
assert(fr.interpreter_frame_method() == m(), "bad method");
RegisterMap reg_map(thread, false);
javaVFrame* triggerVF = thread->last_java_vframe(&reg_map);
// triggerVF is the frame that triggered its counter
RFrame* first = new InterpretedRFrame(triggerVF->fr(), thread, m());
if (first->top_method()->code() != NULL) {
// called obsolete method/nmethod -- no need to recompile
} else {
GrowableArray<RFrame*>* stack = new GrowableArray<RFrame*>(50);
stack->push(first);
RFrame* top = findTopInlinableFrame(stack);
assert(top != NULL, "findTopInlinableFrame returned null");
CompileBroker::compile_method(top->top_method(), InvocationEntryBci, comp_level,
m, hot_count, CompileTask::Reason_InvocationCount, thread);
}
}
}
void StackWalkCompPolicy::method_back_branch_event(const methodHandle& m, int bci, JavaThread* thread) {
const int comp_level = CompLevel_highest_tier;
const int hot_count = m->backedge_count();
if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
CompileBroker::compile_method(m, bci, comp_level, m, hot_count, CompileTask::Reason_BackedgeCount, thread);
NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
}
}
RFrame* StackWalkCompPolicy::findTopInlinableFrame(GrowableArray<RFrame*>* stack) {
// go up the stack until finding a frame that (probably) won't be inlined
// into its caller
RFrame* current = stack->at(0); // current choice for stopping
assert( current && !current->is_compiled(), "" );
const char* msg = NULL;
while (1) {
// before going up the stack further, check if doing so would get us into
// compiled code
RFrame* next = senderOf(current, stack);
if( !next ) // No next frame up the stack?
break; // Then compile with current frame
Method* m = current->top_method();
Method* next_m = next->top_method();
if( !Inline ) { // Inlining turned off
msg = "Inlining turned off";
break;
}
if (next_m->is_not_compilable()) { // Did fail to compile this before/
msg = "caller not compilable";
break;
}
if (next->num() > MaxRecompilationSearchLength) {
// don't go up too high when searching for recompilees
msg = "don't go up any further: > MaxRecompilationSearchLength";
break;
}
if (next->distance() > MaxInterpretedSearchLength) {
// don't go up too high when searching for recompilees
msg = "don't go up any further: next > MaxInterpretedSearchLength";
break;
}
// Compiled frame above already decided not to inline;
// do not recompile him.
if (next->is_compiled()) {
msg = "not going up into optimized code";
break;
}
// Interpreted frame above us was already compiled. Do not force
// a recompile, although if the frame above us runs long enough an
// OSR might still happen.
if( current->is_interpreted() && next_m->has_compiled_code() ) {
msg = "not going up -- already compiled caller";
break;
}
// Compute how frequent this call site is. We have current method 'm'.
// We know next method 'next_m' is interpreted. Find the call site and
// check the various invocation counts.
int invcnt = 0; // Caller counts
if (ProfileInterpreter) {
invcnt = next_m->interpreter_invocation_count();
}
int cnt = 0; // Call site counts
if (ProfileInterpreter && next_m->method_data() != NULL) {
ResourceMark rm;
int bci = next->top_vframe()->bci();
ProfileData* data = next_m->method_data()->bci_to_data(bci);
if (data != NULL && data->is_CounterData())
cnt = data->as_CounterData()->count();
}
// Caller counts / call-site counts; i.e. is this call site
// a hot call site for method next_m?
int freq = (invcnt) ? cnt/invcnt : cnt;
// Check size and frequency limits
if ((msg = shouldInline(m, freq, cnt)) != NULL) {
break;
}
// Check inlining negative tests
if ((msg = shouldNotInline(m)) != NULL) {
break;
}
// If the caller method is too big or something then we do not want to
// compile it just to inline a method
if (!can_be_compiled(next_m, CompLevel_any)) {
msg = "caller cannot be compiled";
break;
}
if( next_m->name() == vmSymbols::class_initializer_name() ) {
msg = "do not compile class initializer (OSR ok)";
break;
}
current = next;
}
assert( !current || !current->is_compiled(), "" );
return current;
}
RFrame* StackWalkCompPolicy::senderOf(RFrame* rf, GrowableArray<RFrame*>* stack) {
RFrame* sender = rf->caller();
if (sender && sender->num() == stack->length()) stack->push(sender);
return sender;
}
const char* StackWalkCompPolicy::shouldInline(const methodHandle& m, float freq, int cnt) {
// Allows targeted inlining
// positive filter: should send be inlined? returns NULL (--> yes)
// or rejection msg
int max_size = MaxInlineSize;
int cost = m->code_size();
// Check for too many throws (and not too huge)
if (m->interpreter_throwout_count() > InlineThrowCount && cost < InlineThrowMaxSize ) {
return NULL;
}
// bump the max size if the call is frequent
if ((freq >= InlineFrequencyRatio) || (cnt >= InlineFrequencyCount)) {
if (TraceFrequencyInlining) {
tty->print("(Inlined frequent method)\n");
m->print();
}
max_size = FreqInlineSize;
}
if (cost > max_size) {
return (_msg = "too big");
}
return NULL;
}
const char* StackWalkCompPolicy::shouldNotInline(const methodHandle& m) {
// negative filter: should send NOT be inlined? returns NULL (--> inline) or rejection msg
if (m->is_abstract()) return (_msg = "abstract method");
// note: we allow ik->is_abstract()
if (!m->method_holder()->is_initialized()) return (_msg = "method holder not initialized");
if (m->is_native()) return (_msg = "native method");
CompiledMethod* m_code = m->code();
if (m_code != NULL && m_code->code_size() > InlineSmallCode)
return (_msg = "already compiled into a big method");
// use frequency-based objections only for non-trivial methods
if (m->code_size() <= MaxTrivialSize) return NULL;
if (UseInterpreter) { // don't use counts with -Xcomp
if ((m->code() == NULL) && m->was_never_executed()) return (_msg = "never executed");
if (!m->was_executed_more_than(MIN2(MinInliningThreshold, CompileThreshold >> 1))) return (_msg = "executed < MinInliningThreshold times");
}
if (Method::has_unloaded_classes_in_signature(m, JavaThread::current())) return (_msg = "unloaded signature classes");
return NULL;
}
#endif // COMPILER2

25
src/hotspot/share/runtime/compilationPolicy.hpp

@ -36,7 +36,6 @@
// interpreted).
class CompileTask;
class CompileQueue;
class RFrame;
class CompilationPolicy : public CHeapObj<mtCompiler> {
static CompilationPolicy* _policy;
@ -116,28 +115,4 @@ class SimpleCompPolicy : public NonTieredCompPolicy {
virtual void method_back_branch_event(const methodHandle& m, int bci, JavaThread* thread);
};
// StackWalkCompPolicy - existing C2 policy
#ifdef COMPILER2
class StackWalkCompPolicy : public NonTieredCompPolicy {
public:
virtual void method_invocation_event(const methodHandle& m, JavaThread* thread);
virtual void method_back_branch_event(const methodHandle& m, int bci, JavaThread* thread);
private:
RFrame* findTopInlinableFrame(GrowableArray<RFrame*>* stack);
RFrame* senderOf(RFrame* rf, GrowableArray<RFrame*>* stack);
// the following variables hold values computed by the last inlining decision
// they are used for performance debugging only (print better messages)
static const char* _msg; // reason for not inlining
static const char* shouldInline (const methodHandle& callee, float frequency, int cnt);
// positive filter: should send be inlined? returns NULL (--> yes) or rejection msg
static const char* shouldNotInline(const methodHandle& callee);
// negative filter: should send NOT be inlined? returns NULL (--> inline) or rejection msg
};
#endif
#endif // SHARE_RUNTIME_COMPILATIONPOLICY_HPP

12
src/hotspot/share/runtime/globals.hpp

@ -1017,10 +1017,6 @@ const size_t minimumSymbolTableSize = 1024;
"Inject thread creation failures for " \
"UseDynamicNumberOfCompilerThreads") \
\
product(intx, CompilationPolicyChoice, 0, \
"which compilation policy (0-2)") \
range(0, 2) \
\
develop(bool, UseStackBanging, true, \
"use stack banging for stack overflow checks (required for " \
"proper StackOverflow handling; disable only to measure cost " \
@ -2143,14 +2139,6 @@ const size_t minimumSymbolTableSize = 1024;
"% of CompileThreshold) before profiling in the interpreter") \
range(0, 100) \
\
develop(intx, MaxRecompilationSearchLength, 10, \
"The maximum number of frames to inspect when searching for " \
"recompilee") \
\
develop(intx, MaxInterpretedSearchLength, 3, \
"The maximum number of interpreted frames to skip when searching "\
"for recompilee") \
\
develop(intx, DesiredMethodLimit, 8000, \
"The desired maximum method size (in bytecodes) after inlining") \
\

180
src/hotspot/share/runtime/rframe.cpp

@ -1,180 +0,0 @@
/*
* Copyright (c) 1997, 2018, 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 "code/codeCache.hpp"
#include "interpreter/interpreter.hpp"
#include "oops/method.inline.hpp"
#include "oops/oop.inline.hpp"
#include "oops/symbol.hpp"
#include "runtime/frame.inline.hpp"
#include "runtime/rframe.hpp"
#include "runtime/vframe.hpp"
#include "runtime/vframe_hp.hpp"
static RFrame*const noCaller = (RFrame*) 0x1; // no caller (i.e., initial frame)
static RFrame*const noCallerYet = (RFrame*) 0x0; // caller not yet computed
RFrame::RFrame(frame fr, JavaThread* thread, RFrame*const callee) :
_fr(fr), _thread(thread), _callee(callee), _num(callee ? callee->num() + 1 : 0) {
_caller = (RFrame*)noCallerYet;
_invocations = 0;
_distance = 0;
}
void RFrame::set_distance(int d) {
assert(is_compiled() || d >= 0, "should be positive");
_distance = d;
}
InterpretedRFrame::InterpretedRFrame(frame fr, JavaThread* thread, RFrame*const callee)
: RFrame(fr, thread, callee) {
RegisterMap map(thread, false);
_vf = javaVFrame::cast(vframe::new_vframe(&_fr, &map, thread));
_method = _vf->method();
assert( _vf->is_interpreted_frame(), "must be interpreted");
init();
}
InterpretedRFrame::InterpretedRFrame(frame fr, JavaThread* thread, Method* m)
: RFrame(fr, thread, NULL) {
RegisterMap map(thread, false);
_vf = javaVFrame::cast(vframe::new_vframe(&_fr, &map, thread));
_method = m;
assert( _vf->is_interpreted_frame(), "must be interpreted");
init();
}
CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread, RFrame*const callee)
: RFrame(fr, thread, callee) {
init();
}
CompiledRFrame::CompiledRFrame(frame fr, JavaThread* thread)
: RFrame(fr, thread, NULL) {
init();
}
DeoptimizedRFrame::DeoptimizedRFrame(frame fr, JavaThread* thread, RFrame*const callee)
: InterpretedRFrame(fr, thread, callee) {}
RFrame* RFrame::new_RFrame(frame fr, JavaThread* thread, RFrame*const callee) {
RFrame* rf = NULL;
int dist = callee ? callee->distance() : -1;
if (fr.is_interpreted_frame()) {
rf = new InterpretedRFrame(fr, thread, callee);
dist++;
} else if (fr.is_compiled_frame()) {
// Even deopted frames look compiled because the deopt
// is invisible until it happens.
rf = new CompiledRFrame(fr, thread, callee);
} else {
assert(false, "Unhandled frame type");
}
if (rf != NULL) {
rf->set_distance(dist);
rf->init();
}
return rf;
}
RFrame* RFrame::caller() {
if (_caller != noCallerYet) return (_caller == noCaller) ? NULL : _caller; // already computed caller
// caller not yet computed; do it now
if (_fr.is_first_java_frame()) {
_caller = (RFrame*)noCaller;
return NULL;
}
RegisterMap map(_thread, false);
frame sender = _fr.real_sender(&map);
if (sender.is_java_frame()) {
_caller = new_RFrame(sender, thread(), this);
return _caller;
}
// Real caller is not java related
_caller = (RFrame*)noCaller;
return NULL;
}
int InterpretedRFrame::cost() const {
return _method->code_size(); // fix this
//return _method->estimated_inline_cost(_receiverKlass);
}
int CompiledRFrame::cost() const {
CompiledMethod* nm = top_method()->code();
if (nm != NULL) {
return nm->insts_size();
} else {
return top_method()->code_size();
}
}
void CompiledRFrame::init() {
RegisterMap map(thread(), false);
vframe* vf = vframe::new_vframe(&_fr, &map, thread());
assert(vf->is_compiled_frame(), "must be compiled");
_nm = compiledVFrame::cast(vf)->code()->as_nmethod();
vf = vf->top();
_vf = javaVFrame::cast(vf);
_method = CodeCache::find_nmethod(_fr.pc())->method();
assert(_method, "should have found a method");
#ifndef PRODUCT
_invocations = _method->compiled_invocation_count();
#endif
}
void InterpretedRFrame::init() {
_invocations = _method->invocation_count() + _method->backedge_count();
}
void RFrame::print(const char* kind) {
#ifndef PRODUCT
#if COMPILER2_OR_JVMCI
int cnt = top_method()->interpreter_invocation_count();
#else
int cnt = top_method()->invocation_count();
#endif
tty->print("%3d %s ", _num, is_interpreted() ? "I" : "C");
top_method()->print_short_name(tty);
tty->print_cr(": inv=%5d(%d) cst=%4d", _invocations, cnt, cost());
#endif
}
void CompiledRFrame::print() {
RFrame::print("comp");
}
void InterpretedRFrame::print() {
RFrame::print("int.");
}
void DeoptimizedRFrame::print() {
RFrame::print("deopt.");
}

125
src/hotspot/share/runtime/rframe.hpp

@ -1,125 +0,0 @@
/*
* Copyright (c) 1997, 2019, 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_RUNTIME_RFRAME_HPP
#define SHARE_RUNTIME_RFRAME_HPP
#include "memory/allocation.hpp"
#include "runtime/frame.hpp"
// rframes ("recompiler frames") decorate stack frames with some extra information
// needed by the recompiler. The recompiler views the stack (at the time of recompilation)
// as a list of rframes.
class RFrame : public ResourceObj {
protected:
const frame _fr; // my frame
JavaThread* const _thread; // thread where frame resides.
RFrame* _caller; // caller / callee rframes (or NULL)
RFrame*const _callee;
const int _num; // stack frame number (0 = most recent)
int _invocations; // current invocation estimate (for this frame)
// (i.e., how often was this frame called)
int _distance; // recompilation search "distance" (measured in # of interpreted frames)
RFrame(frame fr, JavaThread* thread, RFrame*const callee);
virtual void init() = 0; // compute invocations, loopDepth, etc.
void print(const char* name);
public:
static RFrame* new_RFrame(frame fr, JavaThread* thread, RFrame*const callee);
virtual bool is_interpreted() const { return false; }
virtual bool is_compiled() const { return false; }
int distance() const { return _distance; }
void set_distance(int d);
int invocations() const { return _invocations; }
int num() const { return _num; }
frame fr() const { return _fr; }
JavaThread* thread() const { return _thread; }
virtual int cost() const = 0; // estimated inlining cost (size)
virtual Method* top_method() const = 0;
virtual javaVFrame* top_vframe() const = 0;
virtual nmethod* nm() const { ShouldNotCallThis(); return NULL; }
RFrame* caller();
RFrame* callee() const { return _callee; }
RFrame* parent() const; // rframe containing lexical scope (if any)
virtual void print() = 0;
static int computeSends(Method* m);
static int computeSends(nmethod* nm);
static int computeCumulSends(Method* m);
static int computeCumulSends(nmethod* nm);
};
class CompiledRFrame : public RFrame { // frame containing a compiled method
protected:
nmethod* _nm;
javaVFrame* _vf; // top vframe; may be NULL (for most recent frame)
Method* _method; // top method
CompiledRFrame(frame fr, JavaThread* thread, RFrame*const callee);
void init();
friend class RFrame;
public:
CompiledRFrame(frame fr, JavaThread* thread); // for nmethod triggering its counter (callee == NULL)
bool is_compiled() const { return true; }
Method* top_method() const { return _method; }
javaVFrame* top_vframe() const { return _vf; }
nmethod* nm() const { return _nm; }
int cost() const;
void print();
};
class InterpretedRFrame : public RFrame { // interpreter frame
protected:
javaVFrame* _vf; // may be NULL (for most recent frame)
Method* _method;
InterpretedRFrame(frame fr, JavaThread* thread, RFrame*const callee);
void init();
friend class RFrame;
public:
InterpretedRFrame(frame fr, JavaThread* thread, Method* m); // constructor for method triggering its invocation counter
bool is_interpreted() const { return true; }
Method* top_method() const { return _method; }
javaVFrame* top_vframe() const { return _vf; }
int cost() const;
void print();
};
// treat deoptimized frames as interpreted
class DeoptimizedRFrame : public InterpretedRFrame {
protected:
DeoptimizedRFrame(frame fr, JavaThread* thread, RFrame*const callee);
friend class RFrame;
public:
void print();
};
#endif // SHARE_RUNTIME_RFRAME_HPP