jdk-sandbox: comparison hotspot/src/share/vm/compiler/compileBroker.cpp

equal deleted inserted replaced

-:3322a76f3a00
+:ee256e343585
 /*
-* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2016, 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.
 int osr_bci,
 int comp_level,
 const methodHandle& hot_method,
 int hot_count,
 const char* comment,
+bool blocking,
 Thread* thread) {
-// do nothing if compiler thread(s) is not available
-if (!_initialized) {
-return;
-}
 guarantee(!method->is_abstract(), "cannot compile abstract methods");
 assert(method->method_holder()->is_instance_klass(),
 "sanity check");
 assert(!method->method_holder()->is_not_initialized(),
 "method holder must be initialized");
 method->get_method_counters(thread);
 }
 // Outputs from the following MutexLocker block:
 CompileTask* task     = NULL;
-bool         blocking = false;
 CompileQueue* queue  = compile_queue(comp_level);
 // Acquire our lock.
 {
 MutexLocker locker(MethodCompileQueue_lock, thread);
 int compile_id = assign_compile_id(method, osr_bci);
 if (compile_id == 0) {
 // The compilation falls outside the allowed range.
 return;
 }
-// Should this thread wait for completion of the compile?
-blocking = is_compile_blocking();
 #if INCLUDE_JVMCI
 if (UseJVMCICompiler) {
 if (blocking) {
 // Don't allow blocking compiles for requests triggered by JVMCI.
 if (blocking) {
 wait_for_completion(task);
 }
 }
 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) {
+// do nothing if compilebroker is not available
+if (!_initialized) {
+return NULL;
+}
+AbstractCompiler *comp = CompileBroker::compiler(comp_level);
+assert(comp != NULL, "Ensure we don't compile before compilebroker init");
+DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, comp);
+nmethod* nm = CompileBroker::compile_method(method, osr_bci, comp_level, hot_method, hot_count, comment, directive, THREAD);
+DirectivesStack::release(directive);
+return nm;
+}
+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,
+Thread* THREAD) {
 // make sure arguments make sense
 assert(method->method_holder()->is_instance_klass(), "not an instance method");
 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");
 // return quickly if possible
 // lock, make sure that the compilation
 // isn't prohibited in a straightforward way.
 AbstractCompiler *comp = CompileBroker::compiler(comp_level);
-if (comp == NULL || !comp->can_compile_method(method) ||
+if (!comp->can_compile_method(method) ||
-compilation_is_prohibited(method, osr_bci, comp_level)) {
+compilation_is_prohibited(method, osr_bci, comp_level, directive->ExcludeOption)) {
 return NULL;
 }
 if (osr_bci == InvocationEntryBci) {
 // standard compilation
 // fail out now so blocking compiles dont hang the java thread
 if (!should_compile_new_jobs()) {
 CompilationPolicy::policy()->delay_compilation(method());
 return NULL;
 }
-compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, THREAD);
+compile_method_base(method, osr_bci, comp_level, hot_method, hot_count, comment, !directive->BackgroundCompilationOption, THREAD);
 }
 // return requested nmethod
 // We accept a higher level osr method
 if (osr_bci == InvocationEntryBci) {
 // ------------------------------------------------------------------
 // CompileBroker::compilation_is_prohibited
 //
 // See if this compilation is not allowed.
-bool CompileBroker::compilation_is_prohibited(const methodHandle& method, int osr_bci, int comp_level) {
+bool CompileBroker::compilation_is_prohibited(const methodHandle& method, int osr_bci, int comp_level, bool excluded) {
 bool is_native = method->is_native();
 // Some compilers may not support the compilation of natives.
 AbstractCompiler *comp = compiler(comp_level);
 if (is_native &&
 (!CICompileNatives || comp == NULL || !comp->supports_native())) {
 if (is_osr &&
 (!CICompileOSR || comp == NULL || !comp->supports_osr())) {
 method->set_not_osr_compilable(comp_level);
 return true;
 }
-// Breaking the abstraction - directives are only used inside a compilation otherwise.
-DirectiveSet* directive = DirectivesStack::getMatchingDirective(method, comp);
-bool excluded = directive->ExcludeOption;
-DirectivesStack::release(directive);
 // The method may be explicitly excluded by the user.
 double scale;
 if (excluded || (CompilerOracle::has_option_value(method, "CompileThresholdScaling", scale) && scale == 0)) {
 bool quietly = CompilerOracle::should_exclude_quietly();
 // Public wrapper for assign_compile_id that acquires the needed locks
 uint CompileBroker::assign_compile_id_unlocked(Thread* thread, const methodHandle& method, int osr_bci) {
 MutexLocker locker(MethodCompileQueue_lock, thread);
 return assign_compile_id(method, osr_bci);
 }
-/**
-* Should the current thread block until this compilation request
-* has been fulfilled?
-*/
-bool CompileBroker::is_compile_blocking() {
-assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
-return !BackgroundCompilation;
-}
 // ------------------------------------------------------------------
 // CompileBroker::preload_classes
 void CompileBroker::preload_classes(const methodHandle& method, TRAPS) {
 // Move this code over from c1_Compiler.cpp

changeset 36597	ee256e343585
parent 36322	218528915a61
child 36806	b9a6883c30ee
child 37179	4dbcb3a642d2