diff --git a/src/share/vm/ci/ciMethod.cpp b/src/share/vm/ci/ciMethod.cpp index 72aef3fffbb195724ede9b439a357e0cf736bba4..1f66105a9f08042591ff9cc086a71a4aa8523fa1 100644 --- a/src/share/vm/ci/ciMethod.cpp +++ b/src/share/vm/ci/ciMethod.cpp @@ -70,8 +70,7 @@ // Loaded method. ciMethod::ciMethod(methodHandle h_m, ciInstanceKlass* holder) : ciMetadata(h_m()), - _holder(holder), - _has_injected_profile(false) + _holder(holder) { assert(h_m() != NULL, "no null method"); @@ -168,8 +167,7 @@ ciMethod::ciMethod(ciInstanceKlass* holder, _liveness( NULL), _can_be_statically_bound(false), _method_blocks( NULL), - _method_data( NULL), - _has_injected_profile( false) + _method_data( NULL) #if defined(COMPILER2) || defined(SHARK) , _flow( NULL), diff --git a/src/share/vm/ci/ciMethod.hpp b/src/share/vm/ci/ciMethod.hpp index 5217d3928a95f245e6394005673d9e9734cc6d58..af66c4f2dc35fb299a32ca3ba20c8d6644e52c71 100644 --- a/src/share/vm/ci/ciMethod.hpp +++ b/src/share/vm/ci/ciMethod.hpp @@ -78,7 +78,6 @@ class ciMethod : public ciMetadata { bool _is_c1_compilable; bool _is_c2_compilable; bool _can_be_statically_bound; - bool _has_injected_profile; // Lazy fields, filled in on demand address _code; @@ -173,9 +172,9 @@ class ciMethod : public ciMetadata { // Code size for inlining decisions. int code_size_for_inlining(); - bool caller_sensitive() { return get_Method()->caller_sensitive(); } - bool force_inline() { return get_Method()->force_inline(); } - bool dont_inline() { return get_Method()->dont_inline(); } + bool caller_sensitive() const { return get_Method()->caller_sensitive(); } + bool force_inline() const { return get_Method()->force_inline(); } + bool dont_inline() const { return get_Method()->dont_inline(); } int comp_level(); int highest_osr_comp_level(); @@ -283,9 +282,6 @@ class ciMethod : public ciMetadata { int instructions_size(); int scale_count(int count, float prof_factor = 1.); // make MDO count commensurate with IIC - bool has_injected_profile() const { return _has_injected_profile; } - void set_injected_profile(bool x) { _has_injected_profile = x; } - // Stack walking support bool is_ignored_by_security_stack_walk() const; diff --git a/src/share/vm/classfile/classFileParser.cpp b/src/share/vm/classfile/classFileParser.cpp index b3b0336914a1a1e23a47dfbfeab5c604b09884cb..d0fe9efb42e546596dc58f93fe8f2d9849201dc7 100644 --- a/src/share/vm/classfile/classFileParser.cpp +++ b/src/share/vm/classfile/classFileParser.cpp @@ -1783,6 +1783,10 @@ ClassFileParser::AnnotationCollector::annotation_index(ClassLoaderData* loader_d if (_location != _in_method) break; // only allow for methods if (!privileged) break; // only allow in privileged code return _method_DontInline; + case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_InjectedProfile_signature): + if (_location != _in_method) break; // only allow for methods + if (!privileged) break; // only allow in privileged code + return _method_InjectedProfile; case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_LambdaForm_Compiled_signature): if (_location != _in_method) break; // only allow for methods if (!privileged) break; // only allow in privileged code @@ -1824,6 +1828,8 @@ void ClassFileParser::MethodAnnotationCollector::apply_to(methodHandle m) { m->set_force_inline(true); if (has_annotation(_method_DontInline)) m->set_dont_inline(true); + if (has_annotation(_method_InjectedProfile)) + m->set_has_injected_profile(true); if (has_annotation(_method_LambdaForm_Compiled) && m->intrinsic_id() == vmIntrinsics::_none) m->set_intrinsic_id(vmIntrinsics::_compiledLambdaForm); if (has_annotation(_method_LambdaForm_Hidden)) diff --git a/src/share/vm/classfile/classFileParser.hpp b/src/share/vm/classfile/classFileParser.hpp index 0e0c741fc5986ca1f73b24cf34c34b688e92327e..74367f5b931bca8eca5e39a6d9a6727e779f48b6 100644 --- a/src/share/vm/classfile/classFileParser.hpp +++ b/src/share/vm/classfile/classFileParser.hpp @@ -126,6 +126,7 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC { _method_CallerSensitive, _method_ForceInline, _method_DontInline, + _method_InjectedProfile, _method_LambdaForm_Compiled, _method_LambdaForm_Hidden, _sun_misc_Contended, diff --git a/src/share/vm/classfile/vmSymbols.hpp b/src/share/vm/classfile/vmSymbols.hpp index 3fdb90095df5c8fecc8d4927c2365aed007804e1..0a84cb074751d7e1581ce7b274b24afb934454cd 100644 --- a/src/share/vm/classfile/vmSymbols.hpp +++ b/src/share/vm/classfile/vmSymbols.hpp @@ -278,6 +278,7 @@ template(java_lang_invoke_LambdaForm, "java/lang/invoke/LambdaForm") \ template(java_lang_invoke_ForceInline_signature, "Ljava/lang/invoke/ForceInline;") \ template(java_lang_invoke_DontInline_signature, "Ljava/lang/invoke/DontInline;") \ + template(java_lang_invoke_InjectedProfile_signature, "Ljava/lang/invoke/InjectedProfile;") \ template(java_lang_invoke_Stable_signature, "Ljava/lang/invoke/Stable;") \ template(java_lang_invoke_LambdaForm_Compiled_signature, "Ljava/lang/invoke/LambdaForm$Compiled;") \ template(java_lang_invoke_LambdaForm_Hidden_signature, "Ljava/lang/invoke/LambdaForm$Hidden;") \ diff --git a/src/share/vm/oops/method.cpp b/src/share/vm/oops/method.cpp index 4166f52bf9881b4c592eb1db6e68f51ee8d7d5bf..abb67edd0515d1c942085e149631162db7951ac3 100644 --- a/src/share/vm/oops/method.cpp +++ b/src/share/vm/oops/method.cpp @@ -92,6 +92,7 @@ Method::Method(ConstMethod* xconst, AccessFlags access_flags, int size) { set_force_inline(false); set_hidden(false); set_dont_inline(false); + set_has_injected_profile(false); set_method_data(NULL); clear_method_counters(); set_vtable_index(Method::garbage_vtable_index); diff --git a/src/share/vm/oops/method.hpp b/src/share/vm/oops/method.hpp index d6b281cfd89bf0b24446abab4420bc8f8ffe0912..8cef629c5bc7621a6fe97e5e2193326975f87e5c 100644 --- a/src/share/vm/oops/method.hpp +++ b/src/share/vm/oops/method.hpp @@ -110,12 +110,13 @@ class Method : public Metadata { #endif u2 _method_size; // size of this object u1 _intrinsic_id; // vmSymbols::intrinsic_id (0 == _none) - u1 _jfr_towrite : 1, // Flags - _caller_sensitive : 1, - _force_inline : 1, - _hidden : 1, - _dont_inline : 1, - : 3; + u1 _jfr_towrite : 1, // Flags + _caller_sensitive : 1, + _force_inline : 1, + _hidden : 1, + _dont_inline : 1, + _has_injected_profile : 1, + : 2; #ifndef PRODUCT int _compiled_invocation_count; // Number of nmethod invocations so far (for perf. debugging) @@ -781,16 +782,19 @@ class Method : public Metadata { void init_intrinsic_id(); // updates from _none if a match static vmSymbols::SID klass_id_for_intrinsics(Klass* holder); - bool jfr_towrite() { return _jfr_towrite; } - void set_jfr_towrite(bool x) { _jfr_towrite = x; } - bool caller_sensitive() { return _caller_sensitive; } - void set_caller_sensitive(bool x) { _caller_sensitive = x; } - bool force_inline() { return _force_inline; } - void set_force_inline(bool x) { _force_inline = x; } - bool dont_inline() { return _dont_inline; } - void set_dont_inline(bool x) { _dont_inline = x; } - bool is_hidden() { return _hidden; } - void set_hidden(bool x) { _hidden = x; } + bool jfr_towrite() { return _jfr_towrite; } + void set_jfr_towrite(bool x) { _jfr_towrite = x; } + bool caller_sensitive() { return _caller_sensitive; } + void set_caller_sensitive(bool x) { _caller_sensitive = x; } + bool force_inline() { return _force_inline; } + void set_force_inline(bool x) { _force_inline = x; } + bool dont_inline() { return _dont_inline; } + void set_dont_inline(bool x) { _dont_inline = x; } + bool is_hidden() { return _hidden; } + void set_hidden(bool x) { _hidden = x; } + bool has_injected_profile() { return _has_injected_profile; } + void set_has_injected_profile(bool x) { _has_injected_profile = x; } + ConstMethod::MethodType method_type() const { return _constMethod->method_type(); } diff --git a/src/share/vm/opto/compile.cpp b/src/share/vm/opto/compile.cpp index e15a666e26bb01a5f01fee42e9a06221c7253b40..9db624794d66c58a6aeffce383b2834b7447aa61 100644 --- a/src/share/vm/opto/compile.cpp +++ b/src/share/vm/opto/compile.cpp @@ -3292,9 +3292,6 @@ bool Compile::final_graph_reshaping() { bool Compile::too_many_traps(ciMethod* method, int bci, Deoptimization::DeoptReason reason) { - if (method->has_injected_profile()) { - return false; - } ciMethodData* md = method->method_data(); if (md->is_empty()) { // Assume the trap has not occurred, or that it occurred only @@ -3344,9 +3341,6 @@ bool Compile::too_many_traps(Deoptimization::DeoptReason reason, bool Compile::too_many_recompiles(ciMethod* method, int bci, Deoptimization::DeoptReason reason) { - if (method->has_injected_profile()) { - return false; - } ciMethodData* md = method->method_data(); if (md->is_empty()) { // Assume the trap has not occurred, or that it occurred only diff --git a/src/share/vm/opto/library_call.cpp b/src/share/vm/opto/library_call.cpp index 65cf7a53c2c7a1618694b11e6fb97b60c342f7ef..b234d8bb63ffdc2119577c54aae9000653869ab6 100644 --- a/src/share/vm/opto/library_call.cpp +++ b/src/share/vm/opto/library_call.cpp @@ -6565,8 +6565,6 @@ bool LibraryCallKit::inline_profileBoolean() { jint false_cnt = aobj->element_value(0).as_int(); jint true_cnt = aobj->element_value(1).as_int(); - method()->set_injected_profile(true); - if (C->log() != NULL) { C->log()->elem("observe source='profileBoolean' false='%d' true='%d'", false_cnt, true_cnt); diff --git a/src/share/vm/runtime/deoptimization.cpp b/src/share/vm/runtime/deoptimization.cpp index 5d62f26e330d5bb4d6e39f9af5e53977777a9484..c21b86c034760cc5700a04bc4e18843489685e75 100644 --- a/src/share/vm/runtime/deoptimization.cpp +++ b/src/share/vm/runtime/deoptimization.cpp @@ -1469,7 +1469,10 @@ JRT_ENTRY(void, Deoptimization::uncommon_trap_inner(JavaThread* thread, jint tra // // The other actions cause immediate removal of the present code. - bool update_trap_state = true; + // Traps caused by injected profile shouldn't pollute trap counts. + bool injected_profile_trap = trap_method->has_injected_profile() && + (reason == Reason_intrinsic || reason == Reason_unreached); + bool update_trap_state = !injected_profile_trap; bool make_not_entrant = false; bool make_not_compilable = false; bool reprofile = false; diff --git a/test/compiler/jsr292/PollutedTrapCounts.java b/test/compiler/jsr292/PollutedTrapCounts.java new file mode 100644 index 0000000000000000000000000000000000000000..36d531117705ef1f2ede7e1e71d83269df2c9026 --- /dev/null +++ b/test/compiler/jsr292/PollutedTrapCounts.java @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2015, 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 + * @bug 8074551 + * @library /testlibrary + * @run main PollutedTrapCounts + */ +import java.lang.invoke.*; +import com.oracle.java.testlibrary.*; + +public class PollutedTrapCounts { + public static void main(String[] args) throws Exception { + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( + "-XX:+IgnoreUnrecognizedVMOptions", + "-XX:-TieredCompilation", "-Xbatch", + "-XX:PerBytecodeRecompilationCutoff=10", "-XX:PerMethodRecompilationCutoff=10", + "-XX:+PrintCompilation", "-XX:+UnlockDiagnosticVMOptions", "-XX:+PrintInlining", + "PollutedTrapCounts$Test"); + + OutputAnalyzer analyzer = new OutputAnalyzer(pb.start()); + + analyzer.shouldHaveExitValue(0); + + analyzer.shouldNotContain("not compilable (disabled)"); + } + + static class Test { + public static final MethodHandle test1; + public static final MethodHandle test2; + public static final MethodHandle empty; + + static { + try { + Class THIS_CLASS = Test.class; + MethodHandles.Lookup LOOKUP = MethodHandles.lookup(); + test1 = LOOKUP.findStatic(THIS_CLASS, "test1", MethodType.methodType(boolean.class, boolean.class)); + test2 = LOOKUP.findStatic(THIS_CLASS, "test2", MethodType.methodType(boolean.class, boolean.class)); + empty = LOOKUP.findStatic(THIS_CLASS, "empty", MethodType.methodType(void.class, boolean.class)); + } catch(Throwable e) { + throw new Error(e); + } + } + + static boolean test1(boolean b) { + return b; + } + static boolean test2(boolean b) { + return true; + } + static void empty(boolean b) {} + + static void test(boolean freqValue, boolean removeInlineBlocker) throws Throwable { + MethodHandle innerGWT = MethodHandles.guardWithTest(test1, empty, empty); + MethodHandle outerGWT = MethodHandles.guardWithTest(test2, innerGWT, innerGWT); + + // Trigger compilation + for (int i = 0; i < 20_000; i++) { + outerGWT.invokeExact(freqValue); + } + + // Trigger deopt & nmethod invalidation + outerGWT.invokeExact(!freqValue); + + // Force inline blocker removal on rare-taken path + if (removeInlineBlocker) { + for (int i = 0; i < 100; i++) { + outerGWT.invokeExact(!freqValue); + } + } + + // Trigger recompilation + for (int i = 0; i < 20_000; i++) { + outerGWT.invokeExact(freqValue); + } + } + + public static void main(String[] args) throws Throwable { + boolean freqValue = true; + boolean removeInlineBlocker = false; + for (int i = 0; i < 20; i++) { + test(freqValue, removeInlineBlocker); + freqValue = !freqValue; + removeInlineBlocker = !removeInlineBlocker; + } + } + } +}