Mercurial > hg > graal-compiler
changeset 9080:b84fd7d73702
8007288: Additional WB API for compiler's testing
Reviewed-by: kvn, vlivanov
line wrap: on
line diff
--- a/src/share/vm/compiler/compileBroker.cpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/oops/method.hpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/oops/methodData.cpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/oops/methodData.hpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/prims/whitebox.cpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/runtime/compilationPolicy.cpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/runtime/compilationPolicy.hpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/utilities/accessFlags.hpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/src/share/vm/utilities/globalDefinitions.hpp Mon Apr 08 07:40:08 2013 -0700 +++ b/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/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/test/compiler/whitebox/CompilerWhiteBoxTest.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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/test/compiler/whitebox/DeoptimizeAllTest.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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/test/compiler/whitebox/DeoptimizeMethodTest.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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/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/test/compiler/whitebox/IsMethodCompilableTest.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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/test/compiler/whitebox/MakeMethodNotCompilableTest.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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/test/compiler/whitebox/SetDontInlineMethodTest.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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/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/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Mon Apr 08 07:40:08 2013 -0700 +++ b/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);