--- a/hotspot/src/share/vm/compiler/compileBroker.cpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/compiler/compileBroker.cpp Tue Apr 09 09:54:17 2013 -0700
@@ -1206,11 +1206,8 @@
assert(osr_bci == InvocationEntryBci || (0 <= osr_bci && osr_bci < method->code_size()), "bci out of range");
assert(!method->is_abstract() && (osr_bci == InvocationEntryBci || !method->is_native()), "cannot compile abstract/native methods");
assert(!method->method_holder()->is_not_initialized(), "method holder must be initialized");
-
- if (!TieredCompilation) {
- comp_level = CompLevel_highest_tier;
- }
-
+ // allow any levels for WhiteBox
+ assert(WhiteBoxAPI || TieredCompilation || comp_level == CompLevel_highest_tier, "only CompLevel_highest_tier must be used in non-tiered");
// return quickly if possible
// lock, make sure that the compilation
--- a/hotspot/src/share/vm/oops/method.hpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/oops/method.hpp Tue Apr 09 09:54:17 2013 -0700
@@ -758,15 +758,19 @@
void print_made_not_compilable(int comp_level, bool is_osr, bool report, const char* reason);
public:
- bool is_not_c1_compilable() const { return access_flags().is_not_c1_compilable(); }
- void set_not_c1_compilable() { _access_flags.set_not_c1_compilable(); }
- bool is_not_c2_compilable() const { return access_flags().is_not_c2_compilable(); }
- void set_not_c2_compilable() { _access_flags.set_not_c2_compilable(); }
+ bool is_not_c1_compilable() const { return access_flags().is_not_c1_compilable(); }
+ void set_not_c1_compilable() { _access_flags.set_not_c1_compilable(); }
+ void clear_not_c1_compilable() { _access_flags.clear_not_c1_compilable(); }
+ bool is_not_c2_compilable() const { return access_flags().is_not_c2_compilable(); }
+ void set_not_c2_compilable() { _access_flags.set_not_c2_compilable(); }
+ void clear_not_c2_compilable() { _access_flags.clear_not_c2_compilable(); }
- bool is_not_c1_osr_compilable() const { return is_not_c1_compilable(); } // don't waste an accessFlags bit
- void set_not_c1_osr_compilable() { set_not_c1_compilable(); } // don't waste an accessFlags bit
- bool is_not_c2_osr_compilable() const { return access_flags().is_not_c2_osr_compilable(); }
- void set_not_c2_osr_compilable() { _access_flags.set_not_c2_osr_compilable(); }
+ bool is_not_c1_osr_compilable() const { return is_not_c1_compilable(); } // don't waste an accessFlags bit
+ void set_not_c1_osr_compilable() { set_not_c1_compilable(); } // don't waste an accessFlags bit
+ void clear_not_c1_osr_compilable() { clear_not_c1_compilable(); } // don't waste an accessFlags bit
+ bool is_not_c2_osr_compilable() const { return access_flags().is_not_c2_osr_compilable(); }
+ void set_not_c2_osr_compilable() { _access_flags.set_not_c2_osr_compilable(); }
+ void clear_not_c2_osr_compilable() { _access_flags.clear_not_c2_osr_compilable(); }
// Background compilation support
bool queued_for_compilation() const { return access_flags().queued_for_compilation(); }
--- a/hotspot/src/share/vm/oops/methodData.cpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/oops/methodData.cpp Tue Apr 09 09:54:17 2013 -0700
@@ -660,29 +660,9 @@
// Set the method back-pointer.
_method = method();
- _invocation_counter.init();
- _backedge_counter.init();
- _invocation_counter_start = 0;
- _backedge_counter_start = 0;
- _num_loops = 0;
- _num_blocks = 0;
- _highest_comp_level = 0;
- _highest_osr_comp_level = 0;
- _would_profile = true;
+ init();
set_creation_mileage(mileage_of(method()));
- // Initialize flags and trap history.
- _nof_decompiles = 0;
- _nof_overflow_recompiles = 0;
- _nof_overflow_traps = 0;
- _eflags = 0;
- _arg_local = 0;
- _arg_stack = 0;
- _arg_returned = 0;
- assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");
- Copy::zero_to_words((HeapWord*) &_trap_hist,
- sizeof(_trap_hist) / sizeof(HeapWord));
-
// Go through the bytecodes and allocate and initialize the
// corresponding data cells.
int data_size = 0;
@@ -721,7 +701,27 @@
post_initialize(&stream);
set_size(object_size);
+}
+void MethodData::init() {
+ _invocation_counter.init();
+ _backedge_counter.init();
+ _invocation_counter_start = 0;
+ _backedge_counter_start = 0;
+ _num_loops = 0;
+ _num_blocks = 0;
+ _highest_comp_level = 0;
+ _highest_osr_comp_level = 0;
+ _would_profile = true;
+
+ // Initialize flags and trap history.
+ _nof_decompiles = 0;
+ _nof_overflow_recompiles = 0;
+ _nof_overflow_traps = 0;
+ clear_escape_info();
+ assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");
+ Copy::zero_to_words((HeapWord*) &_trap_hist,
+ sizeof(_trap_hist) / sizeof(HeapWord));
}
// Get a measure of how much mileage the method has on it.
--- a/hotspot/src/share/vm/oops/methodData.hpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/oops/methodData.hpp Tue Apr 09 09:54:17 2013 -0700
@@ -1284,8 +1284,8 @@
return bytecode_cell_count(code) != no_profile_data;
}
- // Perform initialization of a new MethodData*
- void initialize(methodHandle method);
+ // reset into original state
+ void init();
// My size
int size_in_bytes() const { return _size; }
@@ -1365,6 +1365,7 @@
intx arg_stack() { return _arg_stack; }
intx arg_returned() { return _arg_returned; }
uint arg_modified(int a) { ArgInfoData *aid = arg_info();
+ assert(aid != NULL, "arg_info must be not null");
assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
return aid->arg_modified(a); }
@@ -1373,8 +1374,8 @@
void set_arg_stack(intx v) { _arg_stack = v; }
void set_arg_returned(intx v) { _arg_returned = v; }
void set_arg_modified(int a, uint v) { ArgInfoData *aid = arg_info();
+ assert(aid != NULL, "arg_info must be not null");
assert(a >= 0 && a < aid->number_of_args(), "valid argument number");
-
aid->set_arg_modified(a, v); }
void clear_escape_info() { _eflags = _arg_local = _arg_stack = _arg_returned = 0; }
--- a/hotspot/src/share/vm/prims/whitebox.cpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/prims/whitebox.cpp Tue Apr 09 09:54:17 2013 -0700
@@ -49,6 +49,7 @@
#endif // INCLUDE_NMT
#include "compiler/compileBroker.hpp"
+#include "runtime/compilationPolicy.hpp"
bool WhiteBox::_used = false;
@@ -213,11 +214,11 @@
return (code->is_alive() && !code->is_marked_for_deoptimization());
WB_END
-WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method))
+WB_ENTRY(jboolean, WB_IsMethodCompilable(JNIEnv* env, jobject o, jobject method, jint comp_level))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
MutexLockerEx mu(Compile_lock);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
- return !mh->is_not_compilable();
+ return CompilationPolicy::can_be_compiled(mh, comp_level);
WB_END
WB_ENTRY(jboolean, WB_IsMethodQueuedForCompilation(JNIEnv* env, jobject o, jobject method))
@@ -241,7 +242,7 @@
mh->set_not_compilable();
WB_END
-WB_ENTRY(jboolean, WB_SetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
+WB_ENTRY(jboolean, WB_TestSetDontInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
jmethodID jmid = reflected_method_to_jmid(thread, env, method);
methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
bool result = mh->dont_inline();
@@ -254,6 +255,54 @@
CompileBroker::queue_size(CompLevel_full_profile) /* C1 */;
WB_END
+
+WB_ENTRY(jboolean, WB_TestSetForceInlineMethod(JNIEnv* env, jobject o, jobject method, jboolean value))
+ jmethodID jmid = reflected_method_to_jmid(thread, env, method);
+ methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
+ bool result = mh->force_inline();
+ mh->set_force_inline(value == JNI_TRUE);
+ return result;
+WB_END
+
+WB_ENTRY(jboolean, WB_EnqueueMethodForCompilation(JNIEnv* env, jobject o, jobject method, jint comp_level))
+ jmethodID jmid = reflected_method_to_jmid(thread, env, method);
+ methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
+ nmethod* nm = CompileBroker::compile_method(mh, InvocationEntryBci, comp_level, mh, mh->invocation_count(), "WhiteBox", THREAD);
+ MutexLockerEx mu(Compile_lock);
+ return (mh->queued_for_compilation() || nm != NULL);
+WB_END
+
+WB_ENTRY(void, WB_ClearMethodState(JNIEnv* env, jobject o, jobject method))
+ jmethodID jmid = reflected_method_to_jmid(thread, env, method);
+ methodHandle mh(THREAD, Method::checked_resolve_jmethod_id(jmid));
+ MutexLockerEx mu(Compile_lock);
+ MethodData* mdo = mh->method_data();
+
+ if (mdo != NULL) {
+ mdo->init();
+ ResourceMark rm;
+ int arg_count = mdo->method()->size_of_parameters();
+ for (int i = 0; i < arg_count; i++) {
+ mdo->set_arg_modified(i, 0);
+ }
+ }
+
+ mh->backedge_counter()->init();
+ mh->invocation_counter()->init();
+ mh->set_interpreter_invocation_count(0);
+ mh->set_interpreter_throwout_count(0);
+ mh->clear_not_c1_compilable();
+ mh->clear_not_c2_compilable();
+ mh->clear_not_c2_osr_compilable();
+ NOT_PRODUCT(mh->set_compiled_invocation_count(0));
+
+#ifdef TIERED
+ mh->set_rate(0.0F);
+ mh->set_prev_event_count(0);
+ mh->set_prev_time(0);
+#endif
+WB_END
+
WB_ENTRY(jboolean, WB_IsInStringTable(JNIEnv* env, jobject o, jstring javaString))
ResourceMark rm(THREAD);
int len;
@@ -271,7 +320,6 @@
Universe::heap()->collect(GCCause::_last_ditch_collection);
WB_END
-
//Some convenience methods to deal with objects from java
int WhiteBox::offset_for_field(const char* field_name, oop object,
Symbol* signature_symbol) {
@@ -349,18 +397,24 @@
(void*)&WB_DeoptimizeMethod },
{CC"isMethodCompiled", CC"(Ljava/lang/reflect/Method;)Z",
(void*)&WB_IsMethodCompiled },
- {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Method;)Z",
+ {CC"isMethodCompilable", CC"(Ljava/lang/reflect/Method;I)Z",
(void*)&WB_IsMethodCompilable},
{CC"isMethodQueuedForCompilation",
CC"(Ljava/lang/reflect/Method;)Z", (void*)&WB_IsMethodQueuedForCompilation},
{CC"makeMethodNotCompilable",
CC"(Ljava/lang/reflect/Method;)V", (void*)&WB_MakeMethodNotCompilable},
- {CC"setDontInlineMethod",
- CC"(Ljava/lang/reflect/Method;Z)Z", (void*)&WB_SetDontInlineMethod},
+ {CC"testSetDontInlineMethod",
+ CC"(Ljava/lang/reflect/Method;Z)Z", (void*)&WB_TestSetDontInlineMethod},
{CC"getMethodCompilationLevel",
CC"(Ljava/lang/reflect/Method;)I", (void*)&WB_GetMethodCompilationLevel},
{CC"getCompileQueuesSize",
CC"()I", (void*)&WB_GetCompileQueuesSize},
+ {CC"testSetForceInlineMethod",
+ CC"(Ljava/lang/reflect/Method;Z)Z", (void*)&WB_TestSetForceInlineMethod},
+ {CC"enqueueMethodForCompilation",
+ CC"(Ljava/lang/reflect/Method;I)Z", (void*)&WB_EnqueueMethodForCompilation},
+ {CC"clearMethodState",
+ CC"(Ljava/lang/reflect/Method;)V", (void*)&WB_ClearMethodState},
{CC"isInStringTable", CC"(Ljava/lang/String;)Z", (void*)&WB_IsInStringTable },
{CC"fullGC", CC"()V", (void*)&WB_FullGC },
};
--- a/hotspot/src/share/vm/runtime/compilationPolicy.cpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/runtime/compilationPolicy.cpp Tue Apr 09 09:54:17 2013 -0700
@@ -123,9 +123,10 @@
}
if (comp_level == CompLevel_all) {
return !m->is_not_compilable(CompLevel_simple) && !m->is_not_compilable(CompLevel_full_optimization);
- } else {
+ } else if (is_compile(comp_level)) {
return !m->is_not_compilable(comp_level);
}
+ return false;
}
bool CompilationPolicy::is_compilation_enabled() {
--- a/hotspot/src/share/vm/runtime/compilationPolicy.hpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/runtime/compilationPolicy.hpp Tue Apr 09 09:54:17 2013 -0700
@@ -96,7 +96,7 @@
void reset_counter_for_back_branch_event(methodHandle method);
public:
NonTieredCompPolicy() : _compiler_count(0) { }
- virtual CompLevel initial_compile_level() { return CompLevel_initial_compile; }
+ virtual CompLevel initial_compile_level() { return CompLevel_highest_tier; }
virtual int compiler_count(CompLevel comp_level);
virtual void do_safepoint_work();
virtual void reprofile(ScopeDesc* trap_scope, bool is_osr);
--- a/hotspot/src/share/vm/utilities/accessFlags.hpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/utilities/accessFlags.hpp Tue Apr 09 09:54:17 2013 -0700
@@ -194,6 +194,9 @@
void set_is_obsolete() { atomic_set_bits(JVM_ACC_IS_OBSOLETE); }
void set_is_prefixed_native() { atomic_set_bits(JVM_ACC_IS_PREFIXED_NATIVE); }
+ void clear_not_c1_compilable() { atomic_clear_bits(JVM_ACC_NOT_C1_COMPILABLE); }
+ void clear_not_c2_compilable() { atomic_clear_bits(JVM_ACC_NOT_C2_COMPILABLE); }
+ void clear_not_c2_osr_compilable() { atomic_clear_bits(JVM_ACC_NOT_C2_OSR_COMPILABLE); }
// Klass* flags
void set_has_vanilla_constructor() { atomic_set_bits(JVM_ACC_HAS_VANILLA_CONSTRUCTOR); }
void set_has_finalizer() { atomic_set_bits(JVM_ACC_HAS_FINALIZER); }
--- a/hotspot/src/share/vm/utilities/globalDefinitions.hpp Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/src/share/vm/utilities/globalDefinitions.hpp Tue Apr 09 09:54:17 2013 -0700
@@ -827,6 +827,10 @@
return comp_level == CompLevel_highest_tier;
}
+inline bool is_compile(int comp_level) {
+ return is_c1_compile(comp_level) || is_c2_compile(comp_level);
+}
+
//----------------------------------------------------------------------------------------------------
// 'Forward' declarations of frequently used classes
// (in order to reduce interface dependencies & reduce
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/whitebox/ClearMethodStateTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 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.
+ */
+
+/*
+ * @test ClearMethodStateTest
+ * @library /testlibrary /testlibrary/whitebox
+ * @build ClearMethodStateTest
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * @run main/othervm -Xbootclasspath/a:. -Xmixed -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ClearMethodStateTest
+ * @author igor.ignatyev@oracle.com
+ */
+public class ClearMethodStateTest extends CompilerWhiteBoxTest {
+ public static void main(String[] args) throws Exception {
+ // to prevent inlining #method into #compile() and #test()
+ WHITE_BOX.testSetDontInlineMethod(METHOD, true);
+ new ClearMethodStateTest().runTest();
+ }
+
+ protected void test() throws Exception {
+ checkNotCompiled(METHOD);
+ compile();
+ checkCompiled(METHOD);
+ WHITE_BOX.clearMethodState(METHOD);
+ WHITE_BOX.deoptimizeMethod(METHOD);
+ checkNotCompiled(METHOD);
+
+
+ if (!TIERED_COMPILATION) {
+ WHITE_BOX.clearMethodState(METHOD);
+ compile(COMPILE_THRESHOLD);
+ checkCompiled(METHOD);
+
+ WHITE_BOX.deoptimizeMethod(METHOD);
+ checkNotCompiled(METHOD);
+ WHITE_BOX.clearMethodState(METHOD);
+
+ if (COMPILE_THRESHOLD > 1) {
+ compile(COMPILE_THRESHOLD - 1);
+ checkNotCompiled(METHOD);
+ } else {
+ System.err.println("Warning: 'CompileThreshold' <= 1");
+ }
+
+ method();
+ checkCompiled(METHOD);
+ } else {
+ System.err.println(
+ "Warning: part of test is not applicable in Tiered");
+ }
+ }
+}
--- a/hotspot/test/compiler/whitebox/CompilerWhiteBoxTest.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/compiler/whitebox/CompilerWhiteBoxTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -37,6 +37,8 @@
= Integer.parseInt(getVMOption("CompileThreshold", "10000"));
protected static final boolean BACKGROUND_COMPILATION
= Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
+ protected static final boolean TIERED_COMPILATION
+ = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
protected static Method getMethod(String name) {
try {
@@ -81,6 +83,9 @@
}
protected static void checkNotCompiled(Method method) {
+ if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
+ throw new RuntimeException(method + " must not be in queue");
+ }
if (WHITE_BOX.isMethodCompiled(method)) {
throw new RuntimeException(method + " must be not compiled");
}
@@ -139,8 +144,11 @@
protected abstract void test() throws Exception;
protected final int compile() {
+ return compile(Math.max(COMPILE_THRESHOLD, 150000));
+ }
+
+ protected final int compile(int count) {
int result = 0;
- int count = Math.max(COMPILE_THRESHOLD, 150000);
for (int i = 0; i < count; ++i) {
result += method();
}
--- a/hotspot/test/compiler/whitebox/DeoptimizeAllTest.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/compiler/whitebox/DeoptimizeAllTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -33,7 +33,7 @@
public static void main(String[] args) throws Exception {
// to prevent inlining #method into #compile()
- WHITE_BOX.setDontInlineMethod(METHOD, true);
+ WHITE_BOX.testSetDontInlineMethod(METHOD, true);
new DeoptimizeAllTest().runTest();
}
--- a/hotspot/test/compiler/whitebox/DeoptimizeMethodTest.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/compiler/whitebox/DeoptimizeMethodTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -33,7 +33,7 @@
public static void main(String[] args) throws Exception {
// to prevent inlining #method into #compile()
- WHITE_BOX.setDontInlineMethod(METHOD, true);
+ WHITE_BOX.testSetDontInlineMethod(METHOD, true);
new DeoptimizeMethodTest().runTest();
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/whitebox/EnqueueMethodForCompilationTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 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.
+ */
+
+/*
+ * @test EnqueueMethodForCompilationTest
+ * @library /testlibrary /testlibrary/whitebox
+ * @build EnqueueMethodForCompilationTest
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * @run main/othervm -Xbootclasspath/a:. -Xmixed -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI EnqueueMethodForCompilationTest
+ * @author igor.ignatyev@oracle.com
+ */
+public class EnqueueMethodForCompilationTest extends CompilerWhiteBoxTest {
+ public static void main(String[] args) throws Exception {
+ // to prevent inlining #method into #compile()
+ WHITE_BOX.testSetDontInlineMethod(METHOD, true);
+ new EnqueueMethodForCompilationTest().runTest();
+ }
+
+ protected void test() throws Exception {
+ checkNotCompiled(METHOD);
+
+ WHITE_BOX.enqueueMethodForCompilation(METHOD, 0);
+ if (WHITE_BOX.isMethodCompilable(METHOD, 0)) {
+ throw new RuntimeException(METHOD + " is compilable at level 0");
+ }
+ checkNotCompiled(METHOD);
+
+ WHITE_BOX.enqueueMethodForCompilation(METHOD, -1);
+ checkNotCompiled(METHOD);
+
+ WHITE_BOX.enqueueMethodForCompilation(METHOD, 5);
+ if (!WHITE_BOX.isMethodCompilable(METHOD, 5)) {
+ checkNotCompiled(METHOD);
+ compile();
+ checkCompiled(METHOD);
+ } else {
+ checkCompiled(METHOD);
+ }
+
+ int compLevel = WHITE_BOX.getMethodCompilationLevel(METHOD);
+ WHITE_BOX.deoptimizeMethod(METHOD);
+ checkNotCompiled(METHOD);
+
+ WHITE_BOX.enqueueMethodForCompilation(METHOD, compLevel);
+ checkCompiled(METHOD);
+ WHITE_BOX.deoptimizeMethod(METHOD);
+ checkNotCompiled(METHOD);
+
+ compile();
+ checkCompiled(METHOD);
+ WHITE_BOX.deoptimizeMethod(METHOD);
+ checkNotCompiled(METHOD);
+ }
+}
--- a/hotspot/test/compiler/whitebox/IsMethodCompilableTest.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/compiler/whitebox/IsMethodCompilableTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -45,7 +45,7 @@
public static void main(String[] args) throws Exception {
// to prevent inlining #method into #compile()
- WHITE_BOX.setDontInlineMethod(METHOD, true);
+ WHITE_BOX.testSetDontInlineMethod(METHOD, true);
new IsMethodCompilableTest().runTest();
}
@@ -60,26 +60,47 @@
"Warning: test is not applicable if PerMethodRecompilationCutoff == Inf");
return;
}
- boolean madeNotCompilable = false;
+
+ // deoptimze 'PerMethodRecompilationCutoff' times and clear state
+ for (long i = 0L, n = PER_METHOD_RECOMPILATION_CUTOFF - 1; i < n; ++i) {
+ compileAndDeoptimaze();
+ }
+ if (!WHITE_BOX.isMethodCompilable(METHOD)) {
+ throw new RuntimeException(METHOD + " is not compilable after "
+ + (PER_METHOD_RECOMPILATION_CUTOFF - 1) + " iterations");
+ }
+ WHITE_BOX.clearMethodState(METHOD);
- for (long i = 0; i < PER_METHOD_RECOMPILATION_CUTOFF; ++i) {
- compile();
- waitBackgroundCompilation(METHOD);
- WHITE_BOX.deoptimizeMethod(METHOD);
- if (!WHITE_BOX.isMethodCompilable(METHOD)) {
- madeNotCompilable = true;
- break;
- }
+ // deoptimze 'PerMethodRecompilationCutoff' + 1 times
+ long i;
+ for (i = 0L; i < PER_METHOD_RECOMPILATION_CUTOFF
+ && WHITE_BOX.isMethodCompilable(METHOD); ++i) {
+ compileAndDeoptimaze();
}
- if (!madeNotCompilable) {
+ if (i != PER_METHOD_RECOMPILATION_CUTOFF) {
+ throw new RuntimeException(METHOD + " is not compilable after "
+ + i + " iterations, but must only after "
+ + PER_METHOD_RECOMPILATION_CUTOFF);
+ }
+ if (WHITE_BOX.isMethodCompilable(METHOD)) {
throw new RuntimeException(METHOD + " is still compilable after "
+ PER_METHOD_RECOMPILATION_CUTOFF + " iterations");
}
compile();
- if (WHITE_BOX.isMethodCompiled(METHOD)) {
- printInfo(METHOD);
- throw new RuntimeException(
- METHOD + " is not compilable but compiled");
+ checkNotCompiled(METHOD);
+
+ WHITE_BOX.clearMethodState(METHOD);
+ if (!WHITE_BOX.isMethodCompilable(METHOD)) {
+ throw new RuntimeException(METHOD
+ + " is compilable after clearMethodState()");
}
+ compile();
+ checkCompiled(METHOD);
+ }
+
+ private void compileAndDeoptimaze() throws Exception {
+ compile();
+ waitBackgroundCompilation(METHOD);
+ WHITE_BOX.deoptimizeMethod(METHOD);
}
}
--- a/hotspot/test/compiler/whitebox/MakeMethodNotCompilableTest.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/compiler/whitebox/MakeMethodNotCompilableTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -33,7 +33,7 @@
public static void main(String[] args) throws Exception {
// to prevent inlining #method into #compile()
- WHITE_BOX.setDontInlineMethod(METHOD, true);
+ WHITE_BOX.testSetDontInlineMethod(METHOD, true);
new MakeMethodNotCompilableTest().runTest();
}
@@ -46,9 +46,6 @@
throw new RuntimeException(METHOD + " must be not compilable");
}
compile();
- if (WHITE_BOX.isMethodQueuedForCompilation(METHOD)) {
- throw new RuntimeException(METHOD + " must not be in queue");
- }
checkNotCompiled(METHOD);
if (WHITE_BOX.isMethodCompilable(METHOD)) {
throw new RuntimeException(METHOD + " must be not compilable");
--- a/hotspot/test/compiler/whitebox/SetDontInlineMethodTest.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/compiler/whitebox/SetDontInlineMethodTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -36,23 +36,23 @@
}
protected void test() throws Exception {
- if (WHITE_BOX.setDontInlineMethod(METHOD, true)) {
+ if (WHITE_BOX.testSetDontInlineMethod(METHOD, true)) {
throw new RuntimeException("on start " + METHOD
+ " must be inlineable");
}
- if (!WHITE_BOX.setDontInlineMethod(METHOD, true)) {
+ if (!WHITE_BOX.testSetDontInlineMethod(METHOD, true)) {
throw new RuntimeException("after first change to true " + METHOD
+ " must be not inlineable");
}
- if (!WHITE_BOX.setDontInlineMethod(METHOD, false)) {
+ if (!WHITE_BOX.testSetDontInlineMethod(METHOD, false)) {
throw new RuntimeException("after second change to true " + METHOD
+ " must be still not inlineable");
}
- if (WHITE_BOX.setDontInlineMethod(METHOD, false)) {
+ if (WHITE_BOX.testSetDontInlineMethod(METHOD, false)) {
throw new RuntimeException("after first change to false" + METHOD
+ " must be inlineable");
}
- if (WHITE_BOX.setDontInlineMethod(METHOD, false)) {
+ if (WHITE_BOX.testSetDontInlineMethod(METHOD, false)) {
throw new RuntimeException("after second change to false " + METHOD
+ " must be inlineable");
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/whitebox/SetForceInlineMethodTest.java Tue Apr 09 09:54:17 2013 -0700
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 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.
+ */
+
+/*
+ * @test SetForceInlineMethodTest
+ * @library /testlibrary /testlibrary/whitebox
+ * @build SetForceInlineMethodTest
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI SetForceInlineMethodTest
+ * @author igor.ignatyev@oracle.com
+ */
+public class SetForceInlineMethodTest extends CompilerWhiteBoxTest {
+
+ public static void main(String[] args) throws Exception {
+ new SetForceInlineMethodTest().runTest();
+ }
+
+ protected void test() throws Exception {
+ if (WHITE_BOX.testSetForceInlineMethod(METHOD, true)) {
+ throw new RuntimeException("on start " + METHOD
+ + " must be not force inlineable");
+ }
+ if (!WHITE_BOX.testSetForceInlineMethod(METHOD, true)) {
+ throw new RuntimeException("after first change to true " + METHOD
+ + " must be force inlineable");
+ }
+ if (!WHITE_BOX.testSetForceInlineMethod(METHOD, false)) {
+ throw new RuntimeException("after second change to true " + METHOD
+ + " must be still force inlineable");
+ }
+ if (WHITE_BOX.testSetForceInlineMethod(METHOD, false)) {
+ throw new RuntimeException("after first change to false" + METHOD
+ + " must be not force inlineable");
+ }
+ if (WHITE_BOX.testSetForceInlineMethod(METHOD, false)) {
+ throw new RuntimeException("after second change to false " + METHOD
+ + " must be not force inlineable");
+ }
+ }
+}
--- a/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Mon Apr 08 07:40:08 2013 -0700
+++ b/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Tue Apr 09 09:54:17 2013 -0700
@@ -87,13 +87,19 @@
// Compiler
public native void deoptimizeAll();
public native boolean isMethodCompiled(Method method);
- public native boolean isMethodCompilable(Method method);
+ public boolean isMethodCompilable(Method method) {
+ return isMethodCompilable(method, -1 /*any*/);
+ }
+ public native boolean isMethodCompilable(Method method, int compLevel);
public native boolean isMethodQueuedForCompilation(Method method);
public native int deoptimizeMethod(Method method);
public native void makeMethodNotCompilable(Method method);
public native int getMethodCompilationLevel(Method method);
- public native boolean setDontInlineMethod(Method method, boolean value);
+ public native boolean testSetDontInlineMethod(Method method, boolean value);
public native int getCompileQueuesSize();
+ public native boolean testSetForceInlineMethod(Method method, boolean value);
+ public native boolean enqueueMethodForCompilation(Method method, int compLevel);
+ public native void clearMethodState(Method method);
//Intered strings
public native boolean isInStringTable(String str);