jdk-sandbox: comparison hotspot/src/share/vm/runtime/thread.cpp

equal deleted inserted replaced

-:7e9ffb1fe1df
+:1572c9f03fb9
 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
 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;
 _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;
 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
 // initialize 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();
 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);
 }

changeset 25946	1572c9f03fb9
parent 25717	7493b8ac31b7
child 26683	a02753d5a0b2