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

equal deleted inserted replaced

-:d01fe40e9cd8
+:5ac4a49f5399
 // ------------------------------------------------------------------
 // CompileBroker::compilation_init
 //
 // Initialize the Compilation object
-void CompileBroker::compilation_init_phase1(TRAPS) {
+void CompileBroker::compilation_init_phase1(Thread* THREAD) {
 // No need to initialize compilation system if we do not use it.
 if (!UseCompiler) {
 return;
 }
 // Set the interface to the current compiler(s).
 // Start the compiler thread(s) and the sweeper thread
 init_compiler_sweeper_threads();
 // totalTime performance counter is always created as it is required
 // by the implementation of java.lang.management.CompilationMBean.
 {
+// Ensure OOM leads to vm_exit_during_initialization.
 EXCEPTION_MARK;
 _perf_total_compilation =
 PerfDataManager::create_counter(JAVA_CI, "totalTime",
 PerfData::U_Ticks, CHECK);
 }
 string,
 CHECK_NH);
 }
-JavaThread* CompileBroker::make_thread(jobject thread_handle, CompileQueue* queue, AbstractCompiler* comp, TRAPS) {
+JavaThread* CompileBroker::make_thread(jobject thread_handle, CompileQueue* queue, AbstractCompiler* comp, Thread* THREAD) {
-JavaThread* thread = NULL;
+JavaThread* new_thread = NULL;
 {
 MutexLocker mu(Threads_lock, THREAD);
 if (comp != NULL) {
 if (!InjectCompilerCreationFailure || comp->num_compiler_threads() == 0) {
 CompilerCounters* counters = new CompilerCounters();
-thread = new CompilerThread(queue, counters);
+new_thread = new CompilerThread(queue, counters);
 }
 } else {
-thread = new CodeCacheSweeperThread();
+new_thread = new CodeCacheSweeperThread();
 }
 // At this point the new CompilerThread data-races with this startup
 // thread (which I believe is the primoridal thread and NOT the VM
 // thread).  This means Java bytecodes being executed at startup can
 // queue compile jobs which will run at whatever default priority the
 // JavaThread due to lack of memory. We would have to throw an exception
 // in that case. However, since this must work and we do not allow
 // exceptions anyway, check and abort if this fails. But first release the
 // lock.
-if (thread != NULL && thread->osthread() != NULL) {
+if (new_thread != NULL && new_thread->osthread() != NULL) {
-java_lang_Thread::set_thread(JNIHandles::resolve_non_null(thread_handle), thread);
+java_lang_Thread::set_thread(JNIHandles::resolve_non_null(thread_handle), new_thread);
 // Note that this only sets the JavaThread _priority field, which by
 // definition is limited to Java priorities and not OS priorities.
 // The os-priority is set in the CompilerThread startup code itself
 native_prio = os::java_to_os_priority[CriticalPriority];
 } else {
 native_prio = os::java_to_os_priority[NearMaxPriority];
 }
 }
-os::set_native_priority(thread, native_prio);
+os::set_native_priority(new_thread, native_prio);
 java_lang_Thread::set_daemon(JNIHandles::resolve_non_null(thread_handle));
-thread->set_threadObj(JNIHandles::resolve_non_null(thread_handle));
+new_thread->set_threadObj(JNIHandles::resolve_non_null(thread_handle));
 if (comp != NULL) {
-thread->as_CompilerThread()->set_compiler(comp);
+new_thread->as_CompilerThread()->set_compiler(comp);
 }
-Threads::add(thread);
+Threads::add(new_thread);
-Thread::start(thread);
+Thread::start(new_thread);
 }
 }
 // First release lock before aborting VM.
-if (thread == NULL || thread->osthread() == NULL) {
+if (new_thread == NULL || new_thread->osthread() == NULL) {
 if (UseDynamicNumberOfCompilerThreads && comp != NULL && comp->num_compiler_threads() > 0) {
-if (thread != NULL) {
+if (new_thread != NULL) {
-thread->smr_delete();
+new_thread->smr_delete();
 }
 return NULL;
 }
 vm_exit_during_initialization("java.lang.OutOfMemoryError",
 os::native_thread_creation_failed_msg());
 }
 // Let go of Threads_lock before yielding
 os::naked_yield(); // make sure that the compiler thread is started early (especially helpful on SOLARIS)
-return thread;
+return new_thread;
 }
 void CompileBroker::init_compiler_sweeper_threads() {
+// Ensure any exceptions lead to vm_exit_during_initialization.
 EXCEPTION_MARK;
 #if !defined(ZERO)
 assert(_c2_count > 0 || _c1_count > 0, "No compilers?");
 #endif // !ZERO
 // Initialize the compilation queue
 JVMCI_ONLY(})
 _compiler2_objects[i] = thread_handle;
 _compiler2_logs[i] = NULL;
 if (!UseDynamicNumberOfCompilerThreads || i == 0) {
-JavaThread *ct = make_thread(thread_handle, _c2_compile_queue, _compilers[1], CHECK);
+JavaThread *ct = make_thread(thread_handle, _c2_compile_queue, _compilers[1], THREAD);
 assert(ct != NULL, "should have been handled for initial thread");
 _compilers[1]->set_num_compiler_threads(i + 1);
 if (TraceCompilerThreads) {
 ResourceMark rm;
 MutexLocker mu(Threads_lock);
 jobject thread_handle = JNIHandles::make_global(thread_oop);
 _compiler1_objects[i] = thread_handle;
 _compiler1_logs[i] = NULL;
 if (!UseDynamicNumberOfCompilerThreads || i == 0) {
-JavaThread *ct = make_thread(thread_handle, _c1_compile_queue, _compilers[0], CHECK);
+JavaThread *ct = make_thread(thread_handle, _c1_compile_queue, _compilers[0], THREAD);
 assert(ct != NULL, "should have been handled for initial thread");
 _compilers[0]->set_num_compiler_threads(i + 1);
 if (TraceCompilerThreads) {
 ResourceMark rm;
 MutexLocker mu(Threads_lock);
 if (MethodFlushing) {
 // Initialize the sweeper thread
 Handle thread_oop = create_thread_oop("Sweeper thread", CHECK);
 jobject thread_handle = JNIHandles::make_local(THREAD, thread_oop());
-make_thread(thread_handle, NULL, NULL, CHECK);
+make_thread(thread_handle, NULL, NULL, THREAD);
 }
 }
-void CompileBroker::possibly_add_compiler_threads() {
+void CompileBroker::possibly_add_compiler_threads(Thread* THREAD) {
-EXCEPTION_MARK;
 julong available_memory = os::available_memory();
 // If SegmentedCodeCache is off, both values refer to the single heap (with type CodeBlobType::All).
 size_t available_cc_np  = CodeCache::unallocated_capacity(CodeBlobType::MethodNonProfiled),
 available_cc_p   = CodeCache::unallocated_capacity(CodeBlobType::MethodProfiled);
 jobject thread_handle = JNIHandles::make_global(thread_oop);
 assert(compiler2_object(i) == NULL, "Old one must be released!");
 _compiler2_objects[i] = thread_handle;
 }
 #endif
-JavaThread *ct = make_thread(compiler2_object(i), _c2_compile_queue, _compilers[1], CHECK);
+JavaThread *ct = make_thread(compiler2_object(i), _c2_compile_queue, _compilers[1], THREAD);
 if (ct == NULL) break;
 _compilers[1]->set_num_compiler_threads(i + 1);
 if (TraceCompilerThreads) {
 ResourceMark rm;
 MutexLocker mu(Threads_lock);
 _c1_compile_queue->size() / 4,
 (int)(available_memory / (100*M)),
 (int)(available_cc_p / (128*K)));
 for (int i = old_c1_count; i < new_c1_count; i++) {
-JavaThread *ct = make_thread(compiler1_object(i), _c1_compile_queue, _compilers[0], CHECK);
+JavaThread *ct = make_thread(compiler1_object(i), _c1_compile_queue, _compilers[0], THREAD);
 if (ct == NULL) break;
 _compilers[0]->set_num_compiler_threads(i + 1);
 if (TraceCompilerThreads) {
 ResourceMark rm;
 MutexLocker mu(Threads_lock);
 MutexLocker locker(MethodCompileQueue_lock, thread);
 return assign_compile_id(method, osr_bci);
 }
 // ------------------------------------------------------------------
-// CompileBroker::preload_classes
-void CompileBroker::preload_classes(const methodHandle& method, TRAPS) {
-// Move this code over from c1_Compiler.cpp
-ShouldNotReachHere();
-}
-// ------------------------------------------------------------------
 // CompileBroker::create_compile_task
 //
 // Create a CompileTask object representing the current request for
 // compilation.  Add this task to the queue.
 CompileTask* CompileBroker::create_compile_task(CompileQueue*       queue,
 task->set_failure_reason("compilation is disabled");
 }
 }
 if (UseDynamicNumberOfCompilerThreads) {
-possibly_add_compiler_threads();
+possibly_add_compiler_threads(thread);
+assert(!thread->has_pending_exception(), "should have been handled");
 }
 }
 }
 // Shut down compiler runtime

changeset 59125	5ac4a49f5399
parent 59056	15936b142f86
child 59249	29b0d0b61615