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

comparison src/share/vm/runtime/thread.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	a29e6e7b7a86 a45a4f5a9609
children	40074f6ac788

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2014, 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.
 #endif
 #ifdef COMPILER2
 #include "opto/c2compiler.hpp"
 #include "opto/idealGraphPrinter.hpp"
 #endif
+#if INCLUDE_RTM_OPT
+#include "runtime/rtmLocking.hpp"
+#endif
+PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 #ifdef DTRACE_ENABLED
 // Only bother with this argument setup if dtrace is available
 // plain initialization
 debug_only(_owned_locks = NULL;)
 debug_only(_allow_allocation_count = 0;)
 NOT_PRODUCT(_allow_safepoint_count = 0;)
 NOT_PRODUCT(_skip_gcalot = false;)
-CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)
 _jvmti_env_iteration_count = 0;
 set_allocated_bytes(0);
 _vm_operation_started_count = 0;
 _vm_operation_completed_count = 0;
 _current_pending_monitor = NULL;
 }
 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().
 //
 // A JavaThread is a normal Java thread
 void JavaThread::initialize() {
 // Initialize fields
-// Set the claimed par_id to -1 (ie not claiming any par_ids)
+// Set the claimed par_id to UINT_MAX (ie not claiming any par_ids)
-set_claimed_par_id(-1);
+set_claimed_par_id(UINT_MAX);
 _buffer_blob = NULL;
 set_saved_exception_pc(NULL);
 set_threadObj(NULL);
 _anchor.clear();
 set_entry_point(NULL);
 // 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();
+Metaspace::post_initialize();
 #ifndef USDT2
 HS_DTRACE_PROBE(hotspot, vm__init__end);
 #else /* USDT2 */
 HOTSPOT_VM_INIT_END();
 #endif /* USDT2 */
 if (MemProfiling)                   MemProfiler::engage();
 StatSampler::engage();
 if (CheckJNICalls)                  JniPeriodicChecker::engage();
 BiasedLocking::init();
+#if INCLUDE_RTM_OPT
+RTMLockingCounters::init();
+#endif
 if (JDK_Version::current().post_vm_init_hook_enabled()) {
 call_postVMInitHook(THREAD);
 // The Java side of PostVMInitHook.run must deal with all
 // exceptions and provide means of diagnosis.
 {
 // 4945125 The vm thread comes to a safepoint during exit.
 // GC vm_operations can get caught at the safepoint, and the
 // heap is unparseable if they are caught. Grab the Heap_lock
 // to prevent this. The GC vm_operations will not be able to
-// queue until after the vm thread is dead.
+// queue until after the vm thread is dead. After this point,
-// After this point, we'll never emerge out of the safepoint before
+// we'll never emerge out of the safepoint before the VM exits.
-// the VM exits, so concurrent GC threads do not need to be explicitly
-// stopped; they remain inactive until the process exits.
-// Note: some concurrent G1 threads may be running during a safepoint,
-// but these will not be accessing the heap, just some G1-specific side
-// data structures that are not accessed by any other threads but them
-// after this point in a terminal safepoint.
 MutexLocker ml(Heap_lock);
 VMThread::wait_for_vm_thread_exit();
 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint");
 }
 // Threads::print_on() is called at safepoint by VM_PrintThreads operation.
 void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) {
 char buf[32];
-st->print_cr(os::local_time_string(buf, sizeof(buf)));
+st->print_raw_cr(os::local_time_string(buf, sizeof(buf)));
 st->print_cr("Full thread dump %s (%s %s):",
 Abstract_VM_Version::vm_name(),
 Abstract_VM_Version::vm_release(),
 Abstract_VM_Version::vm_info_string()
 for (;;) {
 while (*adr != 0) {
 ++ctr ;
 if ((ctr & 0xFFF) == 0 || !os::is_MP()) {
 if (Yields > 5) {
-// Consider using a simple NakedSleep() instead.
+os::naked_short_sleep(1);
-// 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 @ 18041:52b4284cb496