graal-compiler: src/share/vm/runtime/thread.cpp comparison

comparison src/share/vm/runtime/thread.cpp @ 14909:4ca6dc0799b6

Backout jdk9 merge

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Tue, 01 Apr 2014 13:57:07 +0200
parents	3e9a960f0da1
children	b68a693a7ad4

comparison

equal deleted inserted replaced

-:8db6e76cb658
+:4ca6dc0799b6
 /*
-* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 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.
 #ifdef DTRACE_ENABLED
 // Only bother with this argument setup if dtrace is available
-#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START
+#ifndef USDT2
-#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP
+HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin);
+HS_DTRACE_PROBE_DECL(hotspot, vm__init__end);
+HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,
+intptr_t, intptr_t, bool);
+HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
+intptr_t, intptr_t, bool);
+#define DTRACE_THREAD_PROBE(probe, javathread)                             \
+{                                                                        \
+ResourceMark rm(this);                                                 \
+int len = 0;                                                           \
+const char* name = (javathread)->get_thread_name();                    \
+len = strlen(name);                                                    \
+HS_DTRACE_PROBE5(hotspot, thread__##probe,                             \
+name, len,                                                           \
+java_lang_Thread::thread_id((javathread)->threadObj()),              \
+(javathread)->osthread()->thread_id(),                               \
+java_lang_Thread::is_daemon((javathread)->threadObj()));             \
+}
+#else /* USDT2 */
+#define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_PROBE_START
+#define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_PROBE_STOP
 #define DTRACE_THREAD_PROBE(probe, javathread)                             \
 {                                                                        \
 ResourceMark rm(this);                                                 \
 int len = 0;                                                           \
 (char *) name, len,                                                           \
 java_lang_Thread::thread_id((javathread)->threadObj()),              \
 (uintptr_t) (javathread)->osthread()->thread_id(),                               \
 java_lang_Thread::is_daemon((javathread)->threadObj()));             \
 }
+#endif /* USDT2 */
 #else //  ndef DTRACE_ENABLED
 #define DTRACE_THREAD_PROBE(probe, javathread)
 }
 void Thread::record_stack_base_and_size() {
 set_stack_base(os::current_stack_base());
 set_stack_size(os::current_stack_size());
-if (is_Java_thread()) {
-((JavaThread*) this)->set_stack_overflow_limit();
-}
 // CR 7190089: on Solaris, primordial thread's stack is adjusted
 // in initialize_thread(). Without the adjustment, stack size is
 // incorrect if stack is set to unlimited (ulimit -s unlimited).
 // So far, only Solaris has real implementation of initialize_thread().
 //
 #ifndef PRODUCT
 void JavaThread::record_jump(address target, address instr, const char* file, int line) {
 // This should not need to be atomic as the only way for simultaneous
-// updates is via interrupts. Even then this should be rare or non-existent
+// updates is via interrupts. Even then this should be rare or non-existant
 // and we don't care that much anyway.
 int index = _jmp_ring_index;
 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
 _jmp_ring[index]._target = (intptr_t) target;
 assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 return false;
 }
-void Thread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
+void Thread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 active_handles()->oops_do(f);
 // Do oop for ThreadShadow
 f->do_oop((oop*)&_pending_exception);
 #ifdef GRAAL
 f->do_oop((oop*)&_pending_failed_speculation);
 // This could potentially lead to deadlocks
 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
 // Threads_lock is special, since the safepoint synchronization will not start before this is
 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
 // since it is used to transfer control between JavaThreads and the VMThread
-// Do not *exclude* any locks unless you are absolutely sure it is correct. Ask someone else first!
+// Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first!
 if ( (cur->allow_vm_block() &&
 cur != Threads_lock &&
-cur != Compile_lock &&               // Temporary: should not be necessary when we get separate compilation
+cur != Compile_lock &&               // Temporary: should not be necessary when we get spearate compilation
 cur != VMOperationRequest_lock &&
 cur != VMOperationQueue_lock) ||
 cur->rank() == Mutex::special) {
 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
 }
 // if we didn't have any tasks we could have waited for a long time
 // consider the time_slept zero and reset time_before_loop
 time_slept = 0;
 time_before_loop = now;
 } else {
-// need to recalculate since we might have new tasks in _tasks
+// need to recalulate since we might have new tasks in _tasks
 time_slept = (int) ((now - time_before_loop) / 1000000);
 }
 // Change to task list or spurious wakeup of some kind
 if (timedout || _should_terminate) {
 // The first routine called by a new Java thread
 void JavaThread::run() {
 // initialize thread-local alloc buffer related fields
 this->initialize_tlab();
-// used to test validity of stack trace backs
+// used to test validitity of stack trace backs
 this->record_base_of_stack_pointer();
 // Record real stack base and size.
 this->record_stack_base_and_size();
 _cur_thr->set_processed_thread(NULL);
 }
 }
 };
-void JavaThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
+void JavaThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 // Verify that the deferred card marks have been flushed.
 assert(deferred_card_mark().is_empty(), "Should be empty during GC");
 // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
 // since there may be more than one thread using each ThreadProfiler.
 #ifndef PRODUCT
 _ideal_graph_printer = NULL;
 #endif
 }
-void CompilerThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
+void CompilerThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 JavaThread::oops_do(f, cld_f, cf);
 if (_scanned_nmethod != NULL && cf != NULL) {
 // Safepoints can occur when the sweeper is scanning an nmethod so
 // process it here to make sure it isn't unloaded in the middle of
 // a scan.
 tc->do_thread(wt);
 // If CompilerThreads ever become non-JavaThreads, add them here
 }
-void Threads::initialize_java_lang_classes(JavaThread* main_thread, TRAPS) {
-TraceTime timer("Initialize java.lang classes", TraceStartupTime);
-if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
-create_vm_init_libraries();
-}
-initialize_class(vmSymbols::java_lang_String(), CHECK);
-// Initialize java_lang.System (needed before creating the thread)
-initialize_class(vmSymbols::java_lang_System(), CHECK);
-initialize_class(vmSymbols::java_lang_ThreadGroup(), CHECK);
-Handle thread_group = create_initial_thread_group(CHECK);
-Universe::set_main_thread_group(thread_group());
-initialize_class(vmSymbols::java_lang_Thread(), CHECK);
-oop thread_object = create_initial_thread(thread_group, main_thread, CHECK);
-main_thread->set_threadObj(thread_object);
-// Set thread status to running since main thread has
-// been started and running.
-java_lang_Thread::set_thread_status(thread_object,
-java_lang_Thread::RUNNABLE);
-// The VM creates & returns objects of this class. Make sure it's initialized.
-initialize_class(vmSymbols::java_lang_Class(), CHECK);
-// The VM preresolves methods to these classes. Make sure that they get initialized
-initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK);
-initialize_class(vmSymbols::java_lang_ref_Finalizer(),  CHECK);
-call_initializeSystemClass(CHECK);
-// get the Java runtime name after java.lang.System is initialized
-JDK_Version::set_runtime_name(get_java_runtime_name(THREAD));
-JDK_Version::set_runtime_version(get_java_runtime_version(THREAD));
-// an instance of OutOfMemory exception has been allocated earlier
-initialize_class(vmSymbols::java_lang_OutOfMemoryError(), CHECK);
-initialize_class(vmSymbols::java_lang_NullPointerException(), CHECK);
-initialize_class(vmSymbols::java_lang_ClassCastException(), CHECK);
-initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK);
-initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK);
-initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK);
-initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK);
-initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK);
-}
-void Threads::initialize_jsr292_core_classes(TRAPS) {
-initialize_class(vmSymbols::java_lang_invoke_MethodHandle(), CHECK);
-initialize_class(vmSymbols::java_lang_invoke_MemberName(), CHECK);
-initialize_class(vmSymbols::java_lang_invoke_MethodHandleNatives(), CHECK);
-}
 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
 extern void JDK_Version_init();
 // Check version
 os::init();
 // Initialize system properties.
 Arguments::init_system_properties();
-// So that JDK version can be used as a discriminator when parsing arguments
+// So that JDK version can be used as a discrimintor when parsing arguments
 JDK_Version_init();
 // Update/Initialize System properties after JDK version number is known
 Arguments::init_version_specific_system_properties();
 if (PauseAtStartup) {
 os::pause();
 }
+#ifndef USDT2
+HS_DTRACE_PROBE(hotspot, vm__init__begin);
+#else /* USDT2 */
 HOTSPOT_VM_INIT_BEGIN();
+#endif /* USDT2 */
 // Record VM creation timing statistics
 TraceVmCreationTime create_vm_timer;
 create_vm_timer.start();
 if (os_init_2_result != JNI_OK) return os_init_2_result;
 jint adjust_after_os_result = Arguments::adjust_after_os();
 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
-// initialize TLS
+// intialize TLS
 ThreadLocalStorage::init();
 // Bootstrap native memory tracking, so it can start recording memory
 // activities before worker thread is started. This is the first phase
 // of bootstrapping, VM is currently running in single-thread mode.
 // Make sure we're starting with a clean slate.
 VM_Verify verify_op;
 VMThread::execute(&verify_op);
 }
-Thread* THREAD = Thread::current();
+EXCEPTION_MARK;
 // At this point, the Universe is initialized, but we have not executed
 // any byte code.  Now is a good time (the only time) to dump out the
 // internal state of the JVM for sharing.
 if (DumpSharedSpaces) {
-MetaspaceShared::preload_and_dump(CHECK_JNI_ERR);
+MetaspaceShared::preload_and_dump(CHECK_0);
 ShouldNotReachHere();
 }
 // Always call even when there are not JVMTI environments yet, since environments
 // may be attached late and JVMTI must track phases of VM execution
 JvmtiExport::enter_start_phase();
 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents.
 JvmtiExport::post_vm_start();
-initialize_java_lang_classes(main_thread, CHECK_JNI_ERR);
+{
+TraceTime timer("Initialize java.lang classes", TraceStartupTime);
-// We need this for ClassDataSharing - the initial vm.info property is set
-// with the default value of CDS "sharing" which may be reset through
+if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
-// command line options.
+create_vm_init_libraries();
-reset_vm_info_property(CHECK_JNI_ERR);
+}
+initialize_class(vmSymbols::java_lang_String(), CHECK_0);
+// Initialize java_lang.System (needed before creating the thread)
+initialize_class(vmSymbols::java_lang_System(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ThreadGroup(), CHECK_0);
+Handle thread_group = create_initial_thread_group(CHECK_0);
+Universe::set_main_thread_group(thread_group());
+initialize_class(vmSymbols::java_lang_Thread(), CHECK_0);
+oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0);
+main_thread->set_threadObj(thread_object);
+// Set thread status to running since main thread has
+// been started and running.
+java_lang_Thread::set_thread_status(thread_object,
+java_lang_Thread::RUNNABLE);
+// The VM creates & returns objects of this class. Make sure it's initialized.
+initialize_class(vmSymbols::java_lang_Class(), CHECK_0);
+// The VM preresolves methods to these classes. Make sure that they get initialized
+initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ref_Finalizer(),  CHECK_0);
+call_initializeSystemClass(CHECK_0);
+// get the Java runtime name after java.lang.System is initialized
+JDK_Version::set_runtime_name(get_java_runtime_name(THREAD));
+JDK_Version::set_runtime_version(get_java_runtime_version(THREAD));
+// an instance of OutOfMemory exception has been allocated earlier
+initialize_class(vmSymbols::java_lang_OutOfMemoryError(), CHECK_0);
+initialize_class(vmSymbols::java_lang_NullPointerException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ClassCastException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK_0);
+initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK_0);
+}
+// See        : bugid 4211085.
+// Background : the static initializer of java.lang.Compiler tries to read
+//              property"java.compiler" and read & write property "java.vm.info".
+//              When a security manager is installed through the command line
+//              option "-Djava.security.manager", the above properties are not
+//              readable and the static initializer for java.lang.Compiler fails
+//              resulting in a NoClassDefFoundError.  This can happen in any
+//              user code which calls methods in java.lang.Compiler.
+// Hack :       the hack is to pre-load and initialize this class, so that only
+//              system domains are on the stack when the properties are read.
+//              Currently even the AWT code has calls to methods in java.lang.Compiler.
+//              On the classic VM, java.lang.Compiler is loaded very early to load the JIT.
+// Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and
+//              read and write"java.vm.info" in the default policy file. See bugid 4211383
+//              Once that is done, we should remove this hack.
+initialize_class(vmSymbols::java_lang_Compiler(), CHECK_0);
+// More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to
+// the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot
+// compiler does not get loaded through java.lang.Compiler).  "java -version" with the
+// hotspot vm says "nojit" all the time which is confusing.  So, we reset it here.
+// This should also be taken out as soon as 4211383 gets fixed.
+reset_vm_info_property(CHECK_0);
 quicken_jni_functions();
 // Must be run after init_ft which initializes ft_enabled
 if (TRACE_INITIALIZE() != JNI_OK) {
 // Set flag that basic initialization has completed. Used by exceptions and various
 // debug stuff, that does not work until all basic classes have been initialized.
 set_init_completed();
+#ifndef USDT2
+HS_DTRACE_PROBE(hotspot, vm__init__end);
+#else /* USDT2 */
 HOTSPOT_VM_INIT_END();
+#endif /* USDT2 */
 // record VM initialization completion time
 #if INCLUDE_MANAGEMENT
 Management::record_vm_init_completed();
 #endif // INCLUDE_MANAGEMENT
 // Compute system loader. Note that this has to occur after set_init_completed, since
 // valid exceptions may be thrown in the process.
 // Note that we do not use CHECK_0 here since we are inside an EXCEPTION_MARK and
 // set_init_completed has just been called, causing exceptions not to be shortcut
 // anymore. We call vm_exit_during_initialization directly instead.
-SystemDictionary::compute_java_system_loader(CHECK_JNI_ERR);
+SystemDictionary::compute_java_system_loader(THREAD);
+if (HAS_PENDING_EXCEPTION) {
+vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
+}
 #if INCLUDE_ALL_GCS
 // Support for ConcurrentMarkSweep. This should be cleaned up
 // and better encapsulated. The ugly nested if test would go away
 // once things are properly refactored. XXX YSR
 if (UseConcMarkSweepGC || UseG1GC) {
 if (UseConcMarkSweepGC) {
-ConcurrentMarkSweepThread::makeSurrogateLockerThread(CHECK_JNI_ERR);
+ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD);
 } else {
-ConcurrentMarkThread::makeSurrogateLockerThread(CHECK_JNI_ERR);
+ConcurrentMarkThread::makeSurrogateLockerThread(THREAD);
+}
+if (HAS_PENDING_EXCEPTION) {
+vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
 }
 }
 #endif // INCLUDE_ALL_GCS
 // Always call even when there are not JVMTI environments yet, since environments
 // initialize compiler(s)
 #if defined(COMPILER1) || defined(COMPILER2) || defined(SHARK) || defined(COMPILERGRAAL)
 CompileBroker::compilation_init();
 #endif
-// Pre-initialize some JSR292 core classes to avoid deadlock during class loading.
-// It is done after compilers are initialized, because otherwise compilations of
-// signature polymorphic MH intrinsics can be missed
-// (see SystemDictionary::find_method_handle_intrinsic).
 if (EnableInvokeDynamic) {
-initialize_jsr292_core_classes(CHECK_JNI_ERR);
+// Pre-initialize some JSR292 core classes to avoid deadlock during class loading.
+// It is done after compilers are initialized, because otherwise compilations of
+// signature polymorphic MH intrinsics can be missed
+// (see SystemDictionary::find_method_handle_intrinsic).
+initialize_class(vmSymbols::java_lang_invoke_MethodHandle(), CHECK_0);
+initialize_class(vmSymbols::java_lang_invoke_MemberName(), CHECK_0);
+initialize_class(vmSymbols::java_lang_invoke_MethodHandleNatives(), CHECK_0);
 }
 #if INCLUDE_MANAGEMENT
 Management::initialize(THREAD);
+#endif // INCLUDE_MANAGEMENT
 if (HAS_PENDING_EXCEPTION) {
 // management agent fails to start possibly due to
 // configuration problem and is responsible for printing
 // stack trace if appropriate. Simply exit VM.
 vm_exit(1);
 }
-#endif // INCLUDE_MANAGEMENT
 if (Arguments::has_profile())       FlatProfiler::engage(main_thread, true);
 if (MemProfiling)                   MemProfiler::engage();
 StatSampler::engage();
 if (CheckJNICalls)                  JniPeriodicChecker::engage();
 // Operations on the Threads list for GC.  These are not explicitly locked,
 // but the garbage collector must provide a safe context for them to run.
 // In particular, these things should never be called when the Threads_lock
 // is held by some other thread. (Note: the Safepoint abstraction also
-// uses the Threads_lock to guarantee this property. It also makes sure that
+// uses the Threads_lock to gurantee this property. It also makes sure that
 // all threads gets blocked when exiting or starting).
-void Threads::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
+void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 ALL_JAVA_THREADS(p) {
 p->oops_do(f, cld_f, cf);
 }
 VMThread::vm_thread()->oops_do(f, cld_f, cf);
 }
-void Threads::possibly_parallel_oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
+void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
 // Introduce a mechanism allowing parallel threads to claim threads as
 // root groups.  Overhead should be small enough to use all the time,
 // even in sequential code.
 SharedHeap* sh = SharedHeap::heap();
 // Cannot yet substitute active_workers for n_par_threads
 for (;;) {
 while (*adr != 0) {
 ++ctr ;
 if ((ctr & 0xFFF) == 0 || !os::is_MP()) {
 if (Yields > 5) {
-os::naked_short_sleep(1);
+// Consider using a simple NakedSleep() instead.
+// Then SpinAcquire could be called by non-JVM threads
+Thread::current()->_ParkEvent->park(1) ;
 } else {
 os::NakedYield() ;
 ++Yields ;
 }
 } else {

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/thread.cpp @ 14909:4ca6dc0799b6