truffle: src/share/vm/runtime/thread.cpp comparison

comparison src/share/vm/runtime/thread.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	8f2fb6bec986 d3f3f7677537
children	cecb4e39521c be896a1983c0

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "runtime/javaCalls.hpp"
 #include "runtime/jniPeriodicChecker.hpp"
 #include "runtime/memprofiler.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/objectMonitor.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/osThread.hpp"
 #include "runtime/safepoint.hpp"
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/statSampler.hpp"
 #include "runtime/stubRoutines.hpp"
 set_last_handle_mark(NULL);
 // This initial value ==> never claimed.
 _oops_do_parity = 0;
+_metadata_on_stack_buffer = NULL;
 // the handle mark links itself to last_handle_mark
 new HandleMark(this);
 // plain initialization
 debug_only(_owned_locks = NULL;)
 os::initialize_thread(this);
 #if INCLUDE_NMT
 // record thread's native stack, stack grows downward
 address stack_low_addr = stack_base() - stack_size();
-MemTracker::record_thread_stack(stack_low_addr, stack_size(), this,
+MemTracker::record_thread_stack(stack_low_addr, stack_size());
-CURRENT_PC);
 #endif // INCLUDE_NMT
 }
 Thread::~Thread() {
 // that all started threads do call record_stack_base_and_size(), there is
 // not proper way to enforce that.
 #if INCLUDE_NMT
 if (_stack_base != NULL) {
 address low_stack_addr = stack_base() - stack_size();
-MemTracker::release_thread_stack(low_stack_addr, stack_size(), this);
+MemTracker::release_thread_stack(low_stack_addr, stack_size());
 #ifdef ASSERT
 set_stack_base(NULL);
 #endif
 }
 #endif // INCLUDE_NMT
 assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 return false;
 }
-void Thread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
+void Thread::oops_do(OopClosure* f, CLDClosure* 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);
 int os_prio;
 if (os::get_native_priority(this, &os_prio) == OS_OK) {
 st->print("os_prio=%d ", os_prio);
 }
 st->print("tid=" INTPTR_FORMAT " ", this);
+ext().print_on(st);
 osthread()->print_on(st);
 }
 debug_only(if (WizardMode) print_owned_locks_on(st);)
 }
 cur != Threads_lock &&
 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());
+fatal(err_msg("Thread holding lock at safepoint that vm can block on: %s", cur->name()));
 }
 }
 }
 if (GCALotAtAllSafepoints) {
 set_deopt_nmethod(NULL);
 clear_must_deopt_id();
 set_monitor_chunks(NULL);
 set_next(NULL);
 set_thread_state(_thread_new);
-#if INCLUDE_NMT
-set_recorder(NULL);
-#endif
 _terminated = _not_terminated;
 _privileged_stack_top = NULL;
 _array_for_gc = NULL;
 _suspend_equivalent = false;
 _in_deopt_handler = 0;
 // JVMTI PopFrame support
 _popframe_condition = popframe_inactive;
 _popframe_preserved_args = NULL;
 _popframe_preserved_args_size = 0;
+_frames_to_pop_failed_realloc = 0;
 pd_initialize();
 }
 #if INCLUDE_ALL_GCS
 _jni_attach_state = _attaching_via_jni;
 } else {
 _jni_attach_state = _not_attaching_via_jni;
 }
 assert(deferred_card_mark().is_empty(), "Default MemRegion ctor");
-_safepoint_visible = false;
 }
 bool JavaThread::reguard_stack(address cur_sp) {
 if (_stack_guard_state != stack_guard_yellow_disabled) {
 return true; // Stack already guarded or guard pages not needed.
 // %note runtime_23
 os::ThreadType thr_type = os::java_thread;
 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
 os::java_thread;
 os::create_thread(this, thr_type, stack_sz);
-_safepoint_visible = false;
 // The _osthread may be NULL here because we ran out of memory (too many threads active).
 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller
 // may hold a lock and all locks must be unlocked before throwing the exception (throwing
 // the exception consists of creating the exception object & initializing it, initialization
 // will leave the VM via a JavaCall and then all locks must be unlocked).
 JavaThread::~JavaThread() {
 if (TraceThreadEvents) {
 tty->print_cr("terminate thread %p", this);
 }
-// By now, this thread should already be invisible to safepoint,
-// and its per-thread recorder also collected.
-assert(!is_safepoint_visible(), "wrong state");
-#if INCLUDE_NMT
-assert(get_recorder() == NULL, "Already collected");
-#endif // INCLUDE_NMT
 // JSR166 -- return the parker to the free list
 Parker::Release(_parker);
 _parker = NULL ;
 _cur_thr->set_processed_thread(NULL);
 }
 }
 };
-void JavaThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
+void JavaThread::oops_do(OopClosure* f, CLDClosure* 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.
 }
 // Push the Java priority down to the native thread; needs Threads_lock
 Thread::set_priority(this, prio);
+prepare_ext();
 // Add the new thread to the Threads list and set it in motion.
 // We must have threads lock in order to call Threads::add.
 // It is crucial that we do not block before the thread is
 // added to the Threads list for if a GC happens, then the java_thread oop
 // will not be visited by GC.
 bool CompilerThread::can_call_java() const {
 return _compiler != NULL && _compiler->is_graal();
 }
 #endif
-void CompilerThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
+void CompilerThread::oops_do(OopClosure* f, CLDClosure* 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.
 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
 // 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.
-MemTracker::bootstrap_single_thread();
 // Initialize output stream logging
 ostream_init_log();
 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad
 // Must be before create_vm_init_agents()
 main_thread->create_stack_guard_pages();
 // Initialize Java-Level synchronization subsystem
 ObjectMonitor::Initialize() ;
-// Second phase of bootstrapping, VM is about entering multi-thread mode
-MemTracker::bootstrap_multi_thread();
 // Initialize global modules
 jint status = init_globals();
 if (status != JNI_OK) {
 delete main_thread;
 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
 }
 // Any JVMTI raw monitors entered in onload will transition into
 // real raw monitor. VM is setup enough here for raw monitor enter.
 JvmtiExport::transition_pending_onload_raw_monitors();
-// Fully start NMT
-MemTracker::start();
 // Create the VMThread
 { TraceTime timer("Start VMThread", TraceStartupTime);
 VMThread::create();
 Thread* vmthread = VMThread::vm_thread();
 vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name());
 }
 }
 }
+JavaThread* Threads::find_java_thread_from_java_tid(jlong java_tid) {
+assert(Threads_lock->owned_by_self(), "Must hold Threads_lock");
+JavaThread* java_thread = NULL;
+// Sequential search for now.  Need to do better optimization later.
+for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
+oop tobj = thread->threadObj();
+if (!thread->is_exiting() &&
+tobj != NULL &&
+java_tid == java_lang_Thread::thread_id(tobj)) {
+java_thread = thread;
+break;
+}
+}
+return java_thread;
+}
 // Last thread running calls java.lang.Shutdown.shutdown()
 void JavaThread::invoke_shutdown_hooks() {
 HandleMark hm(this);
 // We could get here with a pending exception, if so clear it now.
 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) {
 _number_of_non_daemon_threads++;
 daemon = false;
 }
-p->set_safepoint_visible(true);
 ThreadService::add_thread(p, daemon);
 // Possible GC point.
 Events::log(p, "Thread added: " INTPTR_FORMAT, p);
 }
 // Make sure that safepoint code disregard this thread. This is needed since
 // the thread might mess around with locks after this point. This can cause it
 // to do callbacks into the safepoint code. However, the safepoint code is not aware
 // of this thread since it is removed from the queue.
 p->set_terminated_value();
-// Now, this thread is not visible to safepoint
-p->set_safepoint_visible(false);
-// once the thread becomes safepoint invisible, we can not use its per-thread
-// recorder. And Threads::do_threads() no longer walks this thread, so we have
-// to release its per-thread recorder here.
-MemTracker::thread_exiting(p);
 } // unlock Threads_lock
 // Since Events::log uses a lock, we grab it outside the Threads_lock
 Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
 }
 // 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 gurantee this property. It also makes sure that
 // all threads gets blocked when exiting or starting).
-void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
+void Threads::oops_do(OopClosure* f, CLDClosure* 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, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
+void Threads::possibly_parallel_oops_do(OopClosure* f, CLDClosure* 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
 // because of G1CollectedHeap::verify() use of
-// SharedHeap::process_strong_roots().  n_par_threads == 0 will
+// SharedHeap::process_roots().  n_par_threads == 0 will
-// turn off parallelism in process_strong_roots while active_workers
+// turn off parallelism in process_roots while active_workers
 // is being used for parallelism elsewhere.
 bool is_par = sh->n_par_threads() > 0;
 assert(!is_par ||
 (SharedHeap::heap()->n_par_threads() ==
 SharedHeap::heap()->workers()->active_workers()), "Mismatch");

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.cpp @ 20804:7848fc12602b