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

8153013: BlockingCompilation test times out

Browse Source 
Task has no invocation count and get stale at once

Reviewed-by: kvn, iveresov, twisti
This commit is contained in:
Nils Eliasson 2016-04-13 14:48:22 +02:00
parent c8593eff81
commit 90d0e9a566
12 changed files with 95 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hotspot/src/share/vm/ci/ciReplay.cpp
View File

@ -552,7 +552,7 @@ class CompileReplay : public StackObj {
}
replay_state = this;
CompileBroker::compile_method(method, entry_bci, comp_level,
methodHandle(), 0, "replay", THREAD);
methodHandle(), 0, CompileTask::Reason_Replay, THREAD);
replay_state = NULL;
reset();
}

4
hotspot/src/share/vm/classfile/classLoader.cpp
View File

@ -1642,7 +1642,7 @@ void ClassLoader::compile_the_world_in(char* name, Handle loader, TRAPS) {
}
// Force compilation
CompileBroker::compile_method(m, InvocationEntryBci, comp_level,
methodHandle(), 0, "CTW", THREAD);
methodHandle(), 0, CompileTask::Reason_CTW, THREAD);
if (HAS_PENDING_EXCEPTION) {
clear_pending_exception_if_not_oom(CHECK);
tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
@ -1658,7 +1658,7 @@ void ClassLoader::compile_the_world_in(char* name, Handle loader, TRAPS) {
m->clear_code();
}
CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_full_optimization,
methodHandle(), 0, "CTW", THREAD);
methodHandle(), 0, CompileTask::Reason_CTW, THREAD);
if (HAS_PENDING_EXCEPTION) {
clear_pending_exception_if_not_oom(CHECK);
tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());

22
hotspot/src/share/vm/compiler/compileBroker.cpp
View File

@ -169,6 +169,8 @@ long CompileBroker::_peak_compilation_time = 0;
CompileQueue* CompileBroker::_c2_compile_queue = NULL;
CompileQueue* CompileBroker::_c1_compile_queue = NULL;
class CompilationLog : public StringEventLog {
public:
CompilationLog() : StringEventLog("Compilation events") {
@ -844,7 +846,7 @@ void CompileBroker::compile_method_base(const methodHandle& method,
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment,
CompileTask::CompileReason compile_reason,
bool blocking,
Thread* thread) {
guarantee(!method->is_abstract(), "cannot compile abstract methods");
@ -860,7 +862,7 @@ void CompileBroker::compile_method_base(const methodHandle& method,
if (osr_bci != InvocationEntryBci) {
tty->print(" osr_bci: %d", osr_bci);
}
tty->print(" level: %d comment: %s count: %d", comp_level, comment, hot_count);
tty->print(" level: %d comment: %s count: %d", comp_level, CompileTask::reason_name(compile_reason), hot_count);
if (!hot_method.is_null()) {
tty->print(" hot: ");
if (hot_method() != method()) {
@ -1024,7 +1026,7 @@ void CompileBroker::compile_method_base(const methodHandle& method,
task = create_compile_task(queue,
compile_id, method,
osr_bci, comp_level,
hot_method, hot_count, comment,
hot_method, hot_count, compile_reason,
blocking);
}
@ -1036,7 +1038,8 @@ void CompileBroker::compile_method_base(const methodHandle& method,
nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci,
int comp_level,
const methodHandle& hot_method, int hot_count,
const char* comment, Thread* THREAD) {
CompileTask::CompileReason compile_reason,
Thread* THREAD) {
// Do nothing if compilebroker is not initalized or compiles are submitted on level none
if (!_initialized || comp_level == CompLevel_none) {
return NULL;
@ -1046,7 +1049,7 @@ nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci,
assert(comp != NULL, "Ensure we have a compiler");
DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, comp);
nmethod* nm = CompileBroker::compile_method(method, osr_bci, comp_level, hot_method, hot_count, comment, directive, THREAD);
nmethod* nm = CompileBroker::compile_method(method, osr_bci, comp_level, hot_method, hot_count, compile_reason, directive, THREAD);
DirectivesStack::release(directive);
return nm;
}
@ -1054,7 +1057,8 @@ nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci,
nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci,
int comp_level,
const methodHandle& hot_method, int hot_count,
const char* comment, DirectiveSet* directive,
CompileTask::CompileReason compile_reason,
DirectiveSet* directive,
Thread* THREAD) {
// make sure arguments make sense
@ -1180,7 +1184,7 @@ nmethod* CompileBroker::compile_method(const methodHandle& method, int osr_bci,
return NULL;
}
bool is_blocking = !directive->BackgroundCompilationOption || CompileTheWorld || ReplayCompiles;
compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, is_blocking, THREAD);
compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, compile_reason, is_blocking, THREAD);
}
// return requested nmethod
@ -1344,11 +1348,11 @@ CompileTask* CompileBroker::create_compile_task(CompileQueue* queue,
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment,
CompileTask::CompileReason compile_reason,
bool blocking) {
CompileTask* new_task = CompileTask::allocate();
new_task->initialize(compile_id, method, osr_bci, comp_level,
hot_method, hot_count, comment,
hot_method, hot_count, compile_reason,
blocking);
queue->add(new_task);
return new_task;

9
hotspot/src/share/vm/compiler/compileBroker.hpp
View File

@ -232,7 +232,7 @@ class CompileBroker: AllStatic {
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment,
CompileTask::CompileReason compile_reason,
bool blocking);
static void wait_for_completion(CompileTask* task);
#if INCLUDE_JVMCI
@ -251,7 +251,7 @@ class CompileBroker: AllStatic {
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment,
CompileTask::CompileReason compile_reason,
bool blocking,
Thread* thread);
@ -289,14 +289,15 @@ public:
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment, Thread* thread);
CompileTask::CompileReason compile_reason,
Thread* thread);
static nmethod* compile_method(const methodHandle& method,
int osr_bci,
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment,
CompileTask::CompileReason compile_reason,
DirectiveSet* directive,
Thread* thread);

12
hotspot/src/share/vm/compiler/compileTask.cpp
View File

@ -82,7 +82,7 @@ void CompileTask::initialize(int compile_id,
int comp_level,
const methodHandle& hot_method,
int hot_count,
const char* comment,
CompileTask::CompileReason compile_reason,
bool is_blocking) {
assert(!_lock->is_locked(), "bad locking");
@ -104,7 +104,7 @@ void CompileTask::initialize(int compile_id,
_hot_method_holder = NULL;
_hot_count = hot_count;
_time_queued = 0; // tidy
_comment = comment;
_compile_reason = compile_reason;
_failure_reason = NULL;
if (LogCompilation) {
@ -309,9 +309,9 @@ void CompileTask::log_task_queued() {
xtty->begin_elem("task_queued");
log_task(xtty);
if (_comment != NULL) {
xtty->print(" comment='%s'", _comment);
}
assert(_compile_reason > CompileTask::Reason_None && _compile_reason < CompileTask::Reason_Count, "Valid values");
xtty->print(" comment='%s'", reason_name(_compile_reason));
if (_hot_method != NULL) {
methodHandle hot(thread, _hot_method);
methodHandle method(thread, _method);
@ -440,3 +440,5 @@ void CompileTask::print_inlining_inner(outputStream* st, ciMethod* method, int i
}
st->cr();
}

48
hotspot/src/share/vm/compiler/compileTask.hpp
View File

@ -40,6 +40,39 @@ class CompileTask : public CHeapObj<mtCompiler> {
friend class VMStructs;
friend class JVMCIVMStructs;
public:
// Different reasons for a compilation
// The order is important - Reason_Whitebox and higher can not become
// stale, see CompileTask::can_become_stale()
// Also mapped to reason_names[]
enum CompileReason {
Reason_None,
Reason_InvocationCount, // Simple/StackWalk-policy
Reason_BackedgeCount, // Simple/StackWalk-policy
Reason_Tiered, // Tiered-policy
Reason_CTW, // Compile the world
Reason_Replay, // ciReplay
Reason_Whitebox, // Whitebox API
Reason_MustBeCompiled, // Java callHelper, LinkResolver
Reason_Bootstrap, // JVMCI bootstrap
Reason_Count
};
static const char* reason_name(CompileTask::CompileReason compile_reason) {
static const char* reason_names[] = {
"no_reason",
"count",
"backedge_count",
"tiered",
"CTW",
"replay",
"whitebox",
"must_be_compiled",
"bootstrap"
};
return reason_names[compile_reason];
}
private:
static CompileTask* _task_free_list;
#ifdef ASSERT
@ -69,7 +102,7 @@ class CompileTask : public CHeapObj<mtCompiler> {
Method* _hot_method; // which method actually triggered this task
jobject _hot_method_holder;
int _hot_count; // information about its invocation counter
const char* _comment; // more info about the task
CompileReason _compile_reason; // more info about the task
const char* _failure_reason;
public:
@ -78,8 +111,8 @@ class CompileTask : public CHeapObj<mtCompiler> {
}
void initialize(int compile_id, const methodHandle& method, int osr_bci, int comp_level,
const methodHandle& hot_method, int hot_count, const char* comment,
bool is_blocking);
const methodHandle& hot_method, int hot_count,
CompileTask::CompileReason compile_reason, bool is_blocking);
static CompileTask* allocate();
static void free(CompileTask* task);
@ -91,6 +124,15 @@ class CompileTask : public CHeapObj<mtCompiler> {
bool is_complete() const { return _is_complete; }
bool is_blocking() const { return _is_blocking; }
bool is_success() const { return _is_success; }
bool can_become_stale() const {
switch (_compile_reason) {
case Reason_BackedgeCount:
case Reason_InvocationCount:
case Reason_Tiered:
return !_is_blocking;
}
return false;
}
#if INCLUDE_JVMCI
bool has_waiter() const { return _has_waiter; }
void clear_waiter() { _has_waiter = false; }

2
hotspot/src/share/vm/jvmci/jvmciCompiler.cpp
View File

@ -85,7 +85,7 @@ void JVMCICompiler::bootstrap() {
if (!mh->is_native() && !mh->is_static() && !mh->is_initializer()) {
ResourceMark rm;
int hot_count = 10; // TODO: what's the appropriate value?
CompileBroker::compile_method(mh, InvocationEntryBci, CompLevel_full_optimization, mh, hot_count, "bootstrap", THREAD);
CompileBroker::compile_method(mh, InvocationEntryBci, CompLevel_full_optimization, mh, hot_count, CompileTask::Reason_Bootstrap, THREAD);
}
}

2
hotspot/src/share/vm/prims/whitebox.cpp
View File

@ -646,7 +646,7 @@ bool WhiteBox::compile_method(Method* method, int comp_level, int bci, Thread* T
return false;
}
methodHandle mh(THREAD, method);
nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), "WhiteBox", THREAD);
nmethod* nm = CompileBroker::compile_method(mh, bci, comp_level, mh, mh->invocation_count(), CompileTask::Reason_Whitebox, THREAD);
MutexLockerEx mu(Compile_lock);
return (mh->queued_for_compilation() || nm != NULL);
}

6
hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp
View File

@ -191,8 +191,8 @@ CompileTask* AdvancedThresholdPolicy::select_task(CompileQueue* compile_queue) {
max_method = method;
} else {
// If a method has been stale for some time, remove it from the queue.
// Blocking tasks don't become stale
if (!task->is_blocking() && is_stale(t, TieredCompileTaskTimeout, method) && !is_old(method)) {
// Blocking tasks and tasks submitted from whitebox API don't become stale
if (task->can_become_stale() && is_stale(t, TieredCompileTaskTimeout, method) && !is_old(method)) {
if (PrintTieredEvents) {
print_event(REMOVE_FROM_QUEUE, method, method, task->osr_bci(), (CompLevel)task->comp_level());
}
@ -491,7 +491,7 @@ CompLevel AdvancedThresholdPolicy::loop_event(Method* method, CompLevel cur_leve
void AdvancedThresholdPolicy::submit_compile(const methodHandle& mh, int bci, CompLevel level, JavaThread* thread) {
int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count();
update_rate(os::javaTimeMillis(), mh());
CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", thread);
CompileBroker::compile_method(mh, bci, level, mh, hot_count, CompileTask::Reason_Tiered, thread);
}
// Handle the invocation event.

14
hotspot/src/share/vm/runtime/compilationPolicy.cpp
View File

@ -130,7 +130,7 @@ void CompilationPolicy::compile_if_required(methodHandle selected_method, TRAPS)
}
CompileBroker::compile_method(selected_method, InvocationEntryBci,
CompilationPolicy::policy()->initial_compile_level(),
methodHandle(), 0, "must_be_compiled", CHECK);
methodHandle(), 0, CompileTask::Reason_MustBeCompiled, CHECK);
}
}
@ -508,12 +508,11 @@ void SimpleCompPolicy::method_invocation_event(const methodHandle& m, JavaThread
const int comp_level = CompLevel_highest_tier;
const int hot_count = m->invocation_count();
reset_counter_for_invocation_event(m);
const char* comment = "count";
if (is_compilation_enabled() && can_be_compiled(m, comp_level)) {
CompiledMethod* nm = m->code();
if (nm == NULL ) {
CompileBroker::compile_method(m, InvocationEntryBci, comp_level, m, hot_count, comment, thread);
CompileBroker::compile_method(m, InvocationEntryBci, comp_level, m, hot_count, CompileTask::Reason_InvocationCount, thread);
}
}
}
@ -521,10 +520,9 @@ void SimpleCompPolicy::method_invocation_event(const methodHandle& m, JavaThread
void SimpleCompPolicy::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();
const char* comment = "backedge_count";
if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread);
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));)
}
}
@ -539,7 +537,6 @@ void StackWalkCompPolicy::method_invocation_event(const methodHandle& m, JavaThr
const int comp_level = CompLevel_highest_tier;
const int hot_count = m->invocation_count();
reset_counter_for_invocation_event(m);
const char* comment = "count";
if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(m, comp_level)) {
ResourceMark rm(thread);
@ -569,7 +566,7 @@ void StackWalkCompPolicy::method_invocation_event(const methodHandle& m, JavaThr
assert(top != NULL, "findTopInlinableFrame returned null");
if (TraceCompilationPolicy) top->print();
CompileBroker::compile_method(top->top_method(), InvocationEntryBci, comp_level,
m, hot_count, comment, thread);
m, hot_count, CompileTask::Reason_InvocationCount, thread);
}
}
}
@ -577,10 +574,9 @@ void StackWalkCompPolicy::method_invocation_event(const methodHandle& m, JavaThr
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();
const char* comment = "backedge_count";
if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread);
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));)
}
}

2
hotspot/src/share/vm/runtime/simpleThresholdPolicy.cpp
View File

@ -265,7 +265,7 @@ void SimpleThresholdPolicy::compile(const methodHandle& mh, int bci, CompLevel l
// Tell the broker to compile the method
void SimpleThresholdPolicy::submit_compile(const methodHandle& mh, int bci, CompLevel level, JavaThread* thread) {
int hot_count = (bci == InvocationEntryBci) ? mh->invocation_count() : mh->backedge_count();
CompileBroker::compile_method(mh, bci, level, mh, hot_count, "tiered", thread);
CompileBroker::compile_method(mh, bci, level, mh, hot_count, CompileTask::Reason_Tiered, thread);
}
// Call and loop predicates determine whether a transition to a higher

18
hotspot/test/compiler/whitebox/BlockingCompilation.java
View File

@ -23,14 +23,13 @@
/*
* @test
* @bug 8150646
* @bug 8150646 8153013
* @summary Add support for blocking compiles through whitebox API
* @library /testlibrary /test/lib /
* @build sun.hotspot.WhiteBox
* compiler.testlibrary.CompilerUtils
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
*
* @run driver ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
* @run main/othervm/timeout=60
* -Xbootclasspath/a:.
* -Xmixed
@ -40,11 +39,10 @@
* BlockingCompilation
*/
import compiler.testlibrary.CompilerUtils;
import java.lang.reflect.Method;
import java.util.Random;
import sun.hotspot.WhiteBox;
import compiler.testlibrary.CompilerUtils;
public class BlockingCompilation {
private static final WhiteBox WB = WhiteBox.getWhiteBox();
@ -77,7 +75,13 @@ public class BlockingCompilation {
// If the compiles are blocking, this call will block until the test time out,
// Progress == success
// (Don't run with -Xcomp since that can cause long timeouts due to many compiles)
WB.enqueueMethodForCompilation(m, highest_level);
if (!WB.enqueueMethodForCompilation(m, highest_level)) {
throw new Exception("Failed to enqueue method on level: " + highest_level);
}
if (!WB.isMethodQueuedForCompilation(m)) {
throw new Exception("Must be enqueued because of locked compilation");
}
// restore state
WB.unlockCompilation();