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

comparison src/share/vm/runtime/thread.cpp @ 4137:04b9a2566eec

Merge with hsx23/hotspot.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 17 Dec 2011 21:40:27 +0100
parents	dc7902820c9b bca17e38de00
children	723df37192d6

comparison

equal deleted inserted replaced

-:9dc19b7d89a3
+:04b9a2566eec
 #endif
 #ifdef TARGET_OS_FAMILY_windows
 # include "os_windows.inline.hpp"
 # include "thread_windows.inline.hpp"
 #endif
+#ifdef TARGET_OS_FAMILY_bsd
+# include "os_bsd.inline.hpp"
+# include "thread_bsd.inline.hpp"
+#endif
 #ifndef SERIALGC
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
 #include "gc_implementation/parallelScavenge/pcTasks.hpp"
 #endif
 #ifdef DTRACE_ENABLED
 // Only bother with this argument setup if dtrace is available
+#ifndef USDT2
 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,
 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;                                                           \
+const char* name = (javathread)->get_thread_name();                    \
+len = strlen(name);                                                    \
+HOTSPOT_THREAD_PROBE_##probe(  /* probe = start, stop */               \
+(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)
 // GC Support
 bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
 jint thread_parity = _oops_do_parity;
 if (thread_parity != strong_roots_parity) {
 jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
-if (res == thread_parity) return true;
+if (res == thread_parity) {
-else {
+return true;
+} else {
 guarantee(res == strong_roots_parity, "Or else what?");
-assert(SharedHeap::heap()->n_par_threads() > 0,
+assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 return false;
 }
 }
-assert(SharedHeap::heap()->n_par_threads() > 0,
+assert(SharedHeap::heap()->workers()->active_workers() > 0,
 "Should only fail when parallel.");
 return false;
 }
 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
 }
 // 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::sun_misc_PostVMInitHook_klass();
+klassOop 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(),
 _stack_guard_state = stack_guard_unused;
 _graal_deopt_info = NULL;
 _exception_oop = NULL;
 _exception_pc  = 0;
 _exception_handler_pc = 0;
-_exception_stack_size = 0;
 _is_method_handle_return = 0;
 _jvmti_thread_state= NULL;
 _should_post_on_exceptions_flag = JNI_FALSE;
 _jvmti_get_loaded_classes_closure = NULL;
 _interp_only_mode    = 0;
 #ifndef SERIALGC
 SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
 DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
 #endif // !SERIALGC
-JavaThread::JavaThread(bool is_attaching) :
+JavaThread::JavaThread(bool is_attaching_via_jni) :
 Thread()
 #ifndef SERIALGC
 , _satb_mark_queue(&_satb_mark_queue_set),
 _dirty_card_queue(&_dirty_card_queue_set)
 #endif // !SERIALGC
 {
 initialize();
-_is_attaching = is_attaching;
+if (is_attaching_via_jni) {
+_jni_attach_state = _attaching_via_jni;
+} else {
+_jni_attach_state = _not_attaching_via_jni;
+}
 assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor");
 }
 bool JavaThread::reguard_stack(address cur_sp) {
 if (_stack_guard_state != stack_guard_yellow_disabled) {
 {
 if (TraceThreadEvents) {
 tty->print_cr("creating thread %p", this);
 }
 initialize();
-_is_attaching = false;
+_jni_attach_state = _not_attaching_via_jni;
 set_entry_point(entry_point);
 // Create the native thread itself.
 // %note runtime_23
 os::ThreadType thr_type = os::java_thread;
 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
 // Execute thread entry point unless this thread has a pending exception
 // or has been stopped before starting.
 // Note: Due to JVM_StopThread we can have pending exceptions already!
 if (!this->has_pending_exception() &&
 !java_lang_Thread::is_stillborn(this->threadObj())) {
+{
+ResourceMark rm(this);
+this->set_native_thread_name(this->get_thread_name());
+}
 HandleMark hm(this);
 this->entry_point()(this, this);
 }
 DTRACE_THREAD_PROBE(stop, this);
 }
 else {
 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen);
 }
 }
-else if (is_attaching()) { // workaround for 6412693 - see 6404306
+else if (is_attaching_via_jni()) { // workaround for 6412693 - see 6404306
 name_str = "<no-name - thread is attaching>";
 }
 else {
 name_str = Thread::name();
 }
 fst.current()->print_value_on(tty,this);
 tty->cr();
 }
 }
+class PrintAndVerifyOopClosure: public OopClosure {
+protected:
+template <class T> inline void do_oop_work(T* p) {
+oop obj = oopDesc::load_decode_heap_oop(p);
+if (obj == NULL) return;
+tty->print(INTPTR_FORMAT ": ", p);
+if (obj->is_oop_or_null()) {
+if (obj->is_objArray()) {
+tty->print_cr("valid objArray: " INTPTR_FORMAT, (oopDesc*) obj);
+} else {
+obj->print();
+}
+} else {
+tty->print_cr("invalid oop: " INTPTR_FORMAT, (oopDesc*) obj);
+}
+tty->cr();
+}
+public:
+virtual void do_oop(oop* p) { do_oop_work(p); }
+virtual void do_oop(narrowOop* p)  { do_oop_work(p); }
+};
+static void oops_print(frame* f, const RegisterMap *map) {
+PrintAndVerifyOopClosure print;
+f->print_value();
+f->oops_do(&print, NULL, (RegisterMap*)map);
+}
+// Print our all the locations that contain oops and whether they are
+// valid or not.  This useful when trying to find the oldest frame
+// where an oop has gone bad since the frame walk is from youngest to
+// oldest.
+void JavaThread::trace_oops() {
+tty->print_cr("[Trace oops]");
+frames_do(oops_print);
+}
 #ifdef ASSERT
 // Print or validate the layout of stack frames
 void JavaThread::print_frame_layout(int depth, bool validate_only) {
 ResourceMark rm;
 }
 if (validate_only) {
 values.validate();
 } else {
 tty->print_cr("[Describe stack layout]");
-values.print();
+values.print(this);
 }
 }
 #endif
 void JavaThread::trace_stack_from(vframe* start_vf) {
 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();
 // 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
 Management::record_vm_init_completed();
 // Compute system loader. Note that this has to occur after set_init_completed, since
 }
 // Notify JVMTI agents that VM initialization is complete - nop if no agents.
 JvmtiExport::post_vm_initialized();
-Chunk::start_chunk_pool_cleaner_task();
+if (CleanChunkPoolAsync) {
+Chunk::start_chunk_pool_cleaner_task();
+}
 // initialize compiler(s)
 CompileBroker::compilation_init();
 Management::initialize(THREAD);
 // 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.
+// After this point, we'll never emerge out of the safepoint before
+// 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");
 VMThread::destroy();
 void Threads::possibly_parallel_oops_do(OopClosure* 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();
-bool is_par = (sh->n_par_threads() > 0);
+// Cannot yet substitute active_workers for n_par_threads
+// because of G1CollectedHeap::verify() use of
+// SharedHeap::process_strong_roots().  n_par_threads == 0 will
+// turn off parallelism in process_strong_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");
 int cp = SharedHeap::heap()->strong_roots_parity();
 ALL_JAVA_THREADS(p) {
 if (p->claim_oops_do(is_par, cp)) {
 p->oops_do(f, cf);
 }
 }
 VMThread* vmt = VMThread::vm_thread();
-if (vmt->claim_oops_do(is_par, cp))
+if (vmt->claim_oops_do(is_par, cp)) {
 vmt->oops_do(f, cf);
+}
 }
 #ifndef SERIALGC
 // Used by ParallelScavenge
 void Threads::create_thread_roots_tasks(GCTaskQueue* q) {

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.cpp @ 4137:04b9a2566eec