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

comparison src/share/vm/runtime/thread.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	957c266d8bc5 c284cf4781f0
children	2cb439954abf

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 #include "interpreter/interpreter.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "jvmtifiles/jvmtiEnv.hpp"
 #include "memory/gcLocker.inline.hpp"
+#include "memory/metaspaceShared.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
 if (UseBiasedLocking) {
 const int alignment = markOopDesc::biased_lock_alignment;
 size_t aligned_size = size + (alignment - sizeof(intptr_t));
 void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
-: os::malloc(aligned_size, flags, CURRENT_PC);
+: AllocateHeap(aligned_size, flags, CURRENT_PC,
+AllocFailStrategy::RETURN_NULL);
 void* aligned_addr     = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
 "JavaThread alignment code overflowed allocated storage");
 if (TraceBiasedLocking) {
 }
 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
 return aligned_addr;
 } else {
 return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)
-: os::malloc(size, flags, CURRENT_PC);
+: AllocateHeap(size, flags, CURRENT_PC, AllocFailStrategy::RETURN_NULL);
 }
 }
 void Thread::operator delete(void* p) {
 if (UseBiasedLocking) {
 // allocated data structures
 set_osthread(NULL);
 set_resource_area(new (mtThread)ResourceArea());
 set_handle_area(new (mtThread) HandleArea(NULL));
+set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(300, true));
 set_active_handles(NULL);
 set_free_handle_block(NULL);
 set_last_handle_mark(NULL);
 // This initial value ==> never claimed.
 // method to complete because it may need to allocate memory to
 // store information for the new thread.
 // initialize structure dependent on thread local storage
 ThreadLocalStorage::set_thread(this);
-// set up any platform-specific state.
-os::initialize_thread();
 }
 void Thread::record_stack_base_and_size() {
 set_stack_base(os::current_stack_base());
 set_stack_size(os::current_stack_size());
+// 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().
+//
+// set up any platform-specific state.
+os::initialize_thread(this);
+#if INCLUDE_NMT
 // record thread's native stack, stack grows downward
-address vm_base = _stack_base - _stack_size;
+address stack_low_addr = stack_base() - stack_size();
-MemTracker::record_virtual_memory_reserve(vm_base, _stack_size,
+MemTracker::record_thread_stack(stack_low_addr, stack_size(), this,
-CURRENT_PC, this);
+CURRENT_PC);
-MemTracker::record_virtual_memory_type(vm_base, mtThreadStack);
+#endif // INCLUDE_NMT
 }
 Thread::~Thread() {
 // Reclaim the objectmonitors from the omFreeList of the moribund thread.
 ObjectSynchronizer::omFlush (this) ;
-MemTracker::record_virtual_memory_release((_stack_base - _stack_size),
+// stack_base can be NULL if the thread is never started or exited before
-_stack_size, this);
+// record_stack_base_and_size called. Although, we would like to ensure
+// 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);
+#ifdef ASSERT
+set_stack_base(NULL);
+#endif
+}
+#endif // INCLUDE_NMT
 // deallocate data structures
 delete resource_area();
 // since the handle marks are using the handle area, we have to deallocated the root
 // handle mark before deallocating the thread's handle area,
 ParkEvent::Release (_SleepEvent)  ; _SleepEvent  = NULL ;
 ParkEvent::Release (_MutexEvent)  ; _MutexEvent  = NULL ;
 ParkEvent::Release (_MuxEvent)    ; _MuxEvent    = NULL ;
 delete handle_area();
+delete metadata_handles();
 // osthread() can be NULL, if creation of thread failed.
 if (osthread() != NULL) os::free_thread(osthread());
 delete _SR_lock;
 void Thread::nmethods_do(CodeBlobClosure* cf) {
 // no nmethods in a generic thread...
 }
+void Thread::metadata_do(void f(Metadata*)) {
+if (metadata_handles() != NULL) {
+for (int i = 0; i< metadata_handles()->length(); i++) {
+f(metadata_handles()->at(i));
+}
+}
+}
 void Thread::print_on(outputStream* st) const {
 // get_priority assumes osthread initialized
 if (osthread() != NULL) {
-st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this);
+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);
 osthread()->print_on(st);
 }
 debug_only(if (WizardMode) print_owned_locks_on(st);)
 }
 #endif
 bool Thread::is_in_stack(address adr) const {
 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
 address end = os::current_stack_pointer();
+// Allow non Java threads to call this without stack_base
+if (_stack_base == NULL) return true;
 if (stack_base() >= adr && adr >= end) return true;
 return false;
 }
 // NOTE: this must be called inside the main thread.
 return os::create_main_thread((JavaThread*)this);
 }
 static void initialize_class(Symbol* class_name, TRAPS) {
-klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
+Klass* klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
-instanceKlass::cast(klass)->initialize(CHECK);
+InstanceKlass::cast(klass)->initialize(CHECK);
 }
 // Creates the initial ThreadGroup
 static Handle create_initial_thread_group(TRAPS) {
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ThreadGroup(), true, CHECK_NH);
+Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ThreadGroup(), true, CHECK_NH);
 instanceKlassHandle klass (THREAD, k);
 Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
 {
 JavaValue result(T_VOID);
 return main_instance;
 }
 // Creates the initial Thread
 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) {
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL);
+Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
 java_lang_Thread::set_thread(thread_oop(), thread);
 java_lang_Thread::set_priority(thread_oop(), NormPriority);
 CHECK_NULL);
 return thread_oop();
 }
 static void call_initializeSystemClass(TRAPS) {
-klassOop k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
+Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::initializeSystemClass_name(),
 vmSymbols::void_method_signature(), CHECK);
 }
 char java_runtime_name[128] = "";
+char java_runtime_version[128] = "";
 // extract the JRE name from sun.misc.Version.java_runtime_name
 static const char* get_java_runtime_name(TRAPS) {
-klassOop k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
+Klass* k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
 Handle(), Handle(), CHECK_AND_CLEAR_NULL);
 fieldDescriptor fd;
 bool found = k != NULL &&
-instanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_name_name(),
+InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_name_name(),
 vmSymbols::string_signature(), &fd);
 if (found) {
 oop name_oop = k->java_mirror()->obj_field(fd.offset());
 if (name_oop == NULL)
 return NULL;
 } else {
 return NULL;
 }
 }
+// extract the JRE version from sun.misc.Version.java_runtime_version
+static const char* get_java_runtime_version(TRAPS) {
+Klass* k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
+Handle(), Handle(), CHECK_AND_CLEAR_NULL);
+fieldDescriptor fd;
+bool found = k != NULL &&
+InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_version_name(),
+vmSymbols::string_signature(), &fd);
+if (found) {
+oop name_oop = k->java_mirror()->obj_field(fd.offset());
+if (name_oop == NULL)
+return NULL;
+const char* name = java_lang_String::as_utf8_string(name_oop,
+java_runtime_version,
+sizeof(java_runtime_version));
+return name;
+} else {
+return NULL;
+}
+}
 // General purpose hook into Java code, run once when the VM is initialized.
 // The Java library method itself may be changed independently from the VM.
 static void call_postVMInitHook(TRAPS) {
-klassOop k = SystemDictionary::PostVMInitHook_klass();
+Klass* k = SystemDictionary::PostVMInitHook_klass();
 instanceKlassHandle klass (THREAD, k);
 if (klass.not_null()) {
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(),
 vmSymbols::void_method_signature(),
 // the vm info string
 ResourceMark rm(THREAD);
 const char *vm_info = VM_Version::vm_info_string();
 // java.lang.System class
-klassOop k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
+Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 // setProperty arguments
 Handle key_str    = java_lang_String::create_from_str("java.vm.info", CHECK);
 Handle value_str  = java_lang_String::create_from_str(vm_info, CHECK);
 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) {
 assert(thread_group.not_null(), "thread group should be specified");
 assert(threadObj() == NULL, "should only create Java thread object once");
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
+Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
 java_lang_Thread::set_thread(thread_oop(), this);
 java_lang_Thread::set_priority(thread_oop(), NormPriority);
 // The watcher thread exists to simulate timer interrupts.  It should
 // be replaced by an abstraction over whatever native support for
 // timer interrupts exists on the platform.
 WatcherThread* WatcherThread::_watcher_thread   = NULL;
+bool WatcherThread::_startable = false;
 volatile bool  WatcherThread::_should_terminate = false;
 WatcherThread::WatcherThread() : Thread() {
 assert(watcher_thread() == NULL, "we can only allocate one WatcherThread");
 if (os::create_thread(this, os::watcher_thread)) {
 os::start_thread(this);
 }
 }
 }
+int WatcherThread::sleep() const {
+MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+// remaining will be zero if there are no tasks,
+// causing the WatcherThread to sleep until a task is
+// enrolled
+int remaining = PeriodicTask::time_to_wait();
+int time_slept = 0;
+// we expect this to timeout - we only ever get unparked when
+// we should terminate or when a new task has been enrolled
+OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
+jlong time_before_loop = os::javaTimeNanos();
+for (;;) {
+bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag, remaining);
+jlong now = os::javaTimeNanos();
+if (remaining == 0) {
+// 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 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) {
+break;
+}
+remaining = PeriodicTask::time_to_wait();
+if (remaining == 0) {
+// Last task was just disenrolled so loop around and wait until
+// another task gets enrolled
+continue;
+}
+remaining -= time_slept;
+if (remaining <= 0)
+break;
+}
+return time_slept;
+}
 void WatcherThread::run() {
 assert(this == watcher_thread(), "just checking");
 this->record_stack_base_and_size();
 this->initialize_thread_local_storage();
 assert(watcher_thread() == Thread::current(),  "thread consistency check");
 assert(watcher_thread() == this,  "thread consistency check");
 // Calculate how long it'll be until the next PeriodicTask work
 // should be done, and sleep that amount of time.
-size_t time_to_wait = PeriodicTask::time_to_wait();
+int time_waited = sleep();
-// we expect this to timeout - we only ever get unparked when
-// we should terminate
-{
-OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
-jlong prev_time = os::javaTimeNanos();
-for (;;) {
-int res= _SleepEvent->park(time_to_wait);
-if (res == OS_TIMEOUT || _should_terminate)
-break;
-// spurious wakeup of some kind
-jlong now = os::javaTimeNanos();
-time_to_wait -= (now - prev_time) / 1000000;
-if (time_to_wait <= 0)
-break;
-prev_time = now;
-}
-}
 if (is_error_reported()) {
 // A fatal error has happened, the error handler(VMError::report_and_die)
 // should abort JVM after creating an error log file. However in some
 // rare cases, the error handler itself might deadlock. Here we try to
 // ShowMessageBoxOnError when it is ready to abort.
 os::sleep(this, 5 * 1000, false);
 }
 }
-PeriodicTask::real_time_tick(time_to_wait);
+PeriodicTask::real_time_tick(time_waited);
-// If we have no more tasks left due to dynamic disenrollment,
-// shut down the thread since we don't currently support dynamic enrollment
-if (PeriodicTask::num_tasks() == 0) {
-_should_terminate = true;
-}
 }
 // Signal that it is terminated
 {
 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
 // Thread destructor usually does this..
 ThreadLocalStorage::set_thread(NULL);
 }
 void WatcherThread::start() {
-if (watcher_thread() == NULL) {
+assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
+if (watcher_thread() == NULL && _startable) {
 _should_terminate = false;
 // Create the single instance of WatcherThread
 new WatcherThread();
 }
 }
+void WatcherThread::make_startable() {
+assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
+_startable = true;
+}
 void WatcherThread::stop() {
+{
+MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+_should_terminate = true;
+OrderAccess::fence();  // ensure WatcherThread sees update in main loop
+WatcherThread* watcher = watcher_thread();
+if (watcher != NULL)
+watcher->unpark();
+}
 // it is ok to take late safepoints here, if needed
 MutexLocker mu(Terminator_lock);
-_should_terminate = true;
-OrderAccess::fence();  // ensure WatcherThread sees update in main loop
-Thread* watcher = watcher_thread();
-if (watcher != NULL)
-watcher->_SleepEvent->unpark();
 while(watcher_thread() != NULL) {
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
 //
 // suspend-equivalent condition solves that timeout problem.
 //
 Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
 Mutex::_as_suspend_equivalent_flag);
 }
+}
+void WatcherThread::unpark() {
+MutexLockerEx ml(PeriodicTask_lock->owned_by_self() ? NULL : PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
+PeriodicTask_lock->notify();
 }
 void WatcherThread::print_on(outputStream* st) const {
 st->print("\"%s\" ", name());
 Thread::print_on(st);
 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;
 JavaThread::~JavaThread() {
 if (TraceThreadEvents) {
 tty->print_cr("terminate thread %p", this);
 }
-// Info NMT that this JavaThread is exiting, its memory
+// By now, this thread should already be invisible to safepoint,
-// recorder should be collected
+// and its per-thread recorder also collected.
 assert(!is_safepoint_visible(), "wrong state");
-MemTracker::thread_exiting(this);
+#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 ;
 tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this);
 if (has_last_Java_frame() ) {
 frame f = last_frame();
 tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp());
 }
-tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
+tty->print_cr(" of type: %s", InstanceKlass::cast(_pending_async_exception->klass())->external_name());
 }
 _pending_async_exception = NULL;
 clear_has_async_exception();
 }
 }
 // Set async. pending exception in thread.
 set_pending_async_exception(java_throwable);
 if (TraceExceptions) {
 ResourceMark rm;
-tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
+tty->print_cr("Pending Async. exception installed of type: %s", InstanceKlass::cast(_pending_async_exception->klass())->external_name());
 }
 // for AbortVMOnException flag
-NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name()));
+NOT_PRODUCT(Exceptions::debug_check_abort(InstanceKlass::cast(_pending_async_exception->klass())->external_name()));
 }
 }
 // Interrupt thread so it will wake up from a potential wait()
 }
 }
 }
 void JavaThread::remove_stack_guard_pages() {
+assert(Thread::current() == this, "from different thread");
 if (_stack_guard_state == stack_guard_unused) return;
 address low_addr = stack_base() - stack_size();
 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
 if (os::allocate_stack_guard_pages()) {
 if (!has_last_Java_frame()) return;
 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
 StackFrameStream fst(this, UseBiasedLocking);
 for(; !fst.is_done(); fst.next()) {
 if (fst.current()->should_be_deoptimized()) {
+if (LogCompilation && xtty != NULL) {
+nmethod* nm = fst.current()->cb()->as_nmethod_or_null();
+xtty->elem("deoptimized thread='" UINTX_FORMAT "' compile_id='%d'",
+this->name(), nm != NULL ? nm->compile_id() : -1);
+}
 Deoptimization::deoptimize(this, *fst.current(), fst.register_map(), Deoptimization::Reason_constraint);
 }
 }
 }
 // Traverse instance variables at the end since the GC may be moving things
 // around using this function
 f->do_oop((oop*) &_threadObj);
 f->do_oop((oop*) &_vm_result);
-f->do_oop((oop*) &_vm_result_2);
 #ifdef GRAAL
 f->do_oop((oop*) &_graal_deopt_info);
 #endif
 f->do_oop((oop*) &_exception_oop);
 f->do_oop((oop*) &_pending_async_exception);
 if (has_last_Java_frame()) {
 // Traverse the execution stack
 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
 fst.current()->nmethods_do(cf);
+}
+}
+}
+void JavaThread::metadata_do(void f(Metadata*)) {
+Thread::metadata_do(f);
+if (has_last_Java_frame()) {
+// Traverse the execution stack to call f() on the methods in the stack
+for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
+fst.current()->metadata_do(f);
+}
+} else if (is_Compiler_thread()) {
+// need to walk ciMetadata in current compile tasks to keep alive.
+CompilerThread* ct = (CompilerThread*)this;
+if (ct->env() != NULL) {
+ct->env()->metadata_do(f);
 }
 }
 }
 // Printing
 // Called by Threads::print() for VM_PrintThreads operation
 void JavaThread::print_on(outputStream *st) const {
 st->print("\"%s\" ", get_thread_name());
 oop thread_oop = threadObj();
-if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop))  st->print("daemon ");
+if (thread_oop != NULL) {
+st->print("#" INT64_FORMAT " ", java_lang_Thread::thread_id(thread_oop));
+if (java_lang_Thread::is_daemon(thread_oop))  st->print("daemon ");
+st->print("prio=%d ", java_lang_Thread::priority(thread_oop));
+}
 Thread::print_on(st);
 // print guess for valid stack memory region (assume 4K pages); helps lock debugging
 st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12));
 if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) {
 st->print_cr("   java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
 // Set the thread field (a JavaThread *) of the
 // oop representing the java_lang_Thread to the new thread (a JavaThread *).
 Handle thread_oop(Thread::current(),
 JNIHandles::resolve_non_null(jni_thread));
-assert(instanceKlass::cast(thread_oop->klass())->is_linked(),
+assert(InstanceKlass::cast(thread_oop->klass())->is_linked(),
 "must be initialized");
 set_threadObj(thread_oop());
 java_lang_Thread::set_thread(thread_oop(), this);
 if (prio == NoPriority) {
 }
 return NULL;
 }
-klassOop JavaThread::security_get_caller_class(int depth) {
+Klass* JavaThread::security_get_caller_class(int depth) {
 vframeStream vfst(this);
 vfst.security_get_caller_frame(depth);
 if (!vfst.at_end()) {
 return vfst.method()->method_holder();
 }
 JavaThread* Threads::_thread_list = NULL;
 int         Threads::_number_of_threads = 0;
 int         Threads::_number_of_non_daemon_threads = 0;
 int         Threads::_return_code = 0;
 size_t      JavaThread::_stack_size_at_create = 0;
+#ifdef ASSERT
+bool        Threads::_vm_complete = false;
+#endif
 // All JavaThreads
 #define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next())
 void os_stream();
 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) {
-Universe::heap()->preload_and_dump(CHECK_0);
+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
 if (AggressiveOpts) {
 {
 // Forcibly initialize java/util/HashMap and mutate the private
 // static final "frontCacheEnabled" field before we start creating instances
 #ifdef ASSERT
-klassOop tmp_k = SystemDictionary::find(vmSymbols::java_util_HashMap(), Handle(), Handle(), CHECK_0);
+Klass* tmp_k = SystemDictionary::find(vmSymbols::java_util_HashMap(), Handle(), Handle(), CHECK_0);
 assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet");
 #endif
-klassOop k_o = SystemDictionary::resolve_or_null(vmSymbols::java_util_HashMap(), Handle(), Handle(), CHECK_0);
+Klass* k_o = SystemDictionary::resolve_or_null(vmSymbols::java_util_HashMap(), Handle(), Handle(), CHECK_0);
 KlassHandle k = KlassHandle(THREAD, k_o);
 guarantee(k.not_null(), "Must find java/util/HashMap");
 instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
 ik->initialize(CHECK_0);
 fieldDescriptor fd;
 }
 if (UseStringCache) {
 // Forcibly initialize java/lang/StringValue and mutate the private
 // static final "stringCacheEnabled" field before we start creating instances
-klassOop k_o = SystemDictionary::resolve_or_null(vmSymbols::java_lang_StringValue(), Handle(), Handle(), CHECK_0);
+Klass* k_o = SystemDictionary::resolve_or_null(vmSymbols::java_lang_StringValue(), Handle(), Handle(), CHECK_0);
 // Possible that StringValue isn't present: if so, silently don't break
 if (k_o != NULL) {
 KlassHandle k = KlassHandle(THREAD, k_o);
 instanceKlassHandle ik = instanceKlassHandle(THREAD, k());
 ik->initialize(CHECK_0);
 initialize_class(vmSymbols::java_lang_Class(), 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));
 } else {
 warning("java.lang.System not initialized");
 }
 // an instance of OutOfMemory exception has been allocated earlier
 #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
 if (CleanChunkPoolAsync) {
 Chunk::start_chunk_pool_cleaner_task();
 }
 // initialize compiler(s)
+#if defined(COMPILER1) || defined(COMPILER2)
 CompileBroker::compilation_init();
+#endif
+#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);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 }
 }
-// Start up the WatcherThread if there are any periodic tasks
+{
-// NOTE:  All PeriodicTasks should be registered by now. If they
+MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
-//   aren't, late joiners might appear to start slowly (we might
+// Make sure the watcher thread can be started by WatcherThread::start()
-//   take a while to process their first tick).
+// or by dynamic enrollment.
-if (PeriodicTask::num_tasks() > 0) {
+WatcherThread::make_startable();
-WatcherThread::start();
+// Start up the WatcherThread if there are any periodic tasks
+// NOTE:  All PeriodicTasks should be registered by now. If they
+//   aren't, late joiners might appear to start slowly (we might
+//   take a while to process their first tick).
+if (PeriodicTask::num_tasks() > 0) {
+WatcherThread::start();
+}
 }
 // Give os specific code one last chance to start
 os::init_3();
 create_vm_timer.end();
+#ifdef ASSERT
+_vm_complete = true;
+#endif
 return JNI_OK;
 }
 // type for the Agent_OnLoad and JVM_OnLoad entry points
 extern "C" {
 void Threads::create_vm_init_agents() {
 extern struct JavaVM_ main_vm;
 AgentLibrary* agent;
 JvmtiExport::enter_onload_phase();
 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
 OnLoadEntry_t  on_load_entry = lookup_agent_on_load(agent);
 if (on_load_entry != NULL) {
 // Invoke the Agent_OnLoad function
 if (this->has_pending_exception()) {
 this->clear_pending_exception();
 }
 EXCEPTION_MARK;
-klassOop k =
+Klass* k =
 SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(),
 THREAD);
 if (k != NULL) {
 // SystemDictionary::resolve_or_null will return null if there was
 // an exception.  If we cannot load the Shutdown class, just don't
 //   + Return to caller
 bool Threads::destroy_vm() {
 JavaThread* thread = JavaThread::current();
+#ifdef ASSERT
+_vm_complete = false;
+#endif
 // Wait until we are the last non-daemon thread to execute
 { MutexLocker nu(Threads_lock);
 while (Threads::number_of_non_daemon_threads() > 1 )
 // This wait should make safepoint checks, wait without a timeout,
 // and wait as a suspend-equivalent condition.
 // 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);
 }
 p->nmethods_do(cf);
 }
 VMThread::vm_thread()->nmethods_do(cf);
 }
+void Threads::metadata_do(void f(Metadata*)) {
+ALL_JAVA_THREADS(p) {
+p->metadata_do(f);
+}
+}
 void Threads::gc_epilogue() {
 ALL_JAVA_THREADS(p) {
 p->gc_epilogue();
 }
 }
 VMThread::vm_thread()->print_on(st);
 st->cr();
 Universe::heap()->print_gc_threads_on(st);
 WatcherThread* wt = WatcherThread::watcher_thread();
-if (wt != NULL) wt->print_on(st);
+if (wt != NULL) {
-st->cr();
+wt->print_on(st);
+st->cr();
+}
 CompileBroker::print_compiler_threads_on(st);
 st->flush();
 }
 // Threads::print_on_error() is called by fatal error handler. It's possible

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.cpp @ 6948:e522a00b91aa