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

comparison src/share/vm/runtime/thread.cpp @ 4970:33df1aeaebbf

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Mon, 27 Feb 2012 13:10:13 +0100
parents	723df37192d6 f1cb6f9cfe21
children	1b8d02e10ee8

comparison

equal deleted inserted replaced

-:2cfb7fb2dce7
+:33df1aeaebbf
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, 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
 #include "interpreter/interpreter.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "jvmtifiles/jvmtiEnv.hpp"
+#include "memory/gcLocker.inline.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/vmThread.hpp"
 #include "runtime/vm_operations.hpp"
 #include "services/attachListener.hpp"
 #include "services/management.hpp"
 #include "services/threadService.hpp"
+#include "trace/traceEventTypes.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/preserveException.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 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);
+set_trace_buffer(NULL);
 _vm_operation_started_count = 0;
 _vm_operation_completed_count = 0;
 _current_pending_monitor = NULL;
 _current_pending_monitor_is_from_java = true;
 _current_waiting_monitor = NULL;
 if (JvmtiExport::should_post_thread_life()) {
 JvmtiExport::post_thread_start(this);
 }
+EVENT_BEGIN(TraceEventThreadStart, event);
+EVENT_COMMIT(event,
+EVENT_SET(event, javalangthread, java_lang_Thread::thread_id(this->threadObj())));
 // We call another function to do the rest so we are sure that the stack addresses used
 // from there will be lower than the stack base just computed
 thread_main_inner();
 // Note, thread is no longer valid at this point!
 if (!destroy_vm || JDK_Version::is_jdk12x_version()) {
 // JSR-166: change call from from ThreadGroup.uncaughtException to
 // java.lang.Thread.dispatchUncaughtException
 if (uncaught_exception.not_null()) {
 Handle group(this, java_lang_Thread::threadGroup(threadObj()));
-Events::log("uncaught exception INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT",
-(address)uncaught_exception(), (address)threadObj(), (address)group());
 {
 EXCEPTION_MARK;
 // Check if the method Thread.dispatchUncaughtException() exists. If so
 // call it.  Otherwise we have an older library without the JSR-166 changes,
 // so call ThreadGroup.uncaughtException()
 CLEAR_PENDING_EXCEPTION;
 }
 }
 }
+// Called before the java thread exit since we want to read info
+// from java_lang_Thread object
+EVENT_BEGIN(TraceEventThreadEnd, event);
+EVENT_COMMIT(event,
+EVENT_SET(event, javalangthread, java_lang_Thread::thread_id(this->threadObj())));
+// Call after last event on thread
+EVENT_THREAD_EXIT(this);
 // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
 // the execution of the method. If that is not enough, then we don't really care. Thread.stop
 // is deprecated anyhow.
 { int count = 3;
 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
 // access error since that may block.
 thread->check_and_handle_async_exceptions(false);
 }
 }
+// This is a variant of the normal
+// check_special_condition_for_native_trans with slightly different
+// semantics for use by critical native wrappers.  It does all the
+// normal checks but also performs the transition back into
+// thread_in_Java state.  This is required so that critical natives
+// can potentially block and perform a GC if they are the last thread
+// exiting the GC_locker.
+void JavaThread::check_special_condition_for_native_trans_and_transition(JavaThread *thread) {
+check_special_condition_for_native_trans(thread);
+// Finish the transition
+thread->set_thread_state(_thread_in_Java);
+if (thread->do_critical_native_unlock()) {
+ThreadInVMfromJavaNoAsyncException tiv(thread);
+GC_locker::unlock_critical(thread);
+thread->clear_critical_native_unlock();
+}
+}
 // We need to guarantee the Threads_lock here, since resumes are not
 // allowed during safepoint synchronization
 // Can only resume from an external suspension
 void JavaThread::java_resume() {
 assert_locked_or_safepoint(Threads_lock);
 initialize_class(vmSymbols::java_lang_ClassCastException(), CHECK_0);
 initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK_0);
 initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK_0);
 initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK_0);
 initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK_0);
+initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK_0);
 } else {
 warning("java.lang.OutOfMemoryError has not been initialized");
 warning("java.lang.NullPointerException has not been initialized");
 warning("java.lang.ClassCastException has not been initialized");
 warning("java.lang.ArrayStoreException has not been initialized");
 warning("java.lang.ArithmeticException has not been initialized");
 warning("java.lang.StackOverflowError has not been initialized");
+warning("java.lang.IllegalArgumentException has not been initialized");
 }
 }
 // See        : bugid 4211085.
 // Background : the static initializer of java.lang.Compiler tries to read
 // This should also be taken out as soon as 4211383 gets fixed.
 reset_vm_info_property(CHECK_0);
 quicken_jni_functions();
+// Must be run after init_ft which initializes ft_enabled
+if (TRACE_INITIALIZE() != JNI_OK) {
+vm_exit_during_initialization("Failed to initialize tracing backend");
+}
 // 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
 // Launch -Xrun agents
 // Must be done in the JVMTI live phase so that for backward compatibility the JDWP
 // back-end can launch with -Xdebug -Xrunjdwp.
 if (!EagerXrunInit && Arguments::init_libraries_at_startup()) {
 create_vm_init_libraries();
+}
+if (!TRACE_START()) {
+vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
 }
 // Notify JVMTI agents that VM initialization is complete - nop if no agents.
 JvmtiExport::post_vm_initialized();
 }
 ThreadService::add_thread(p, daemon);
 // Possible GC point.
-Events::log("Thread added: " INTPTR_FORMAT, p);
+Events::log(p, "Thread added: " INTPTR_FORMAT, p);
 }
 void Threads::remove(JavaThread* p) {
 // Extra scope needed for Thread_lock, so we can check
 // that we do not remove thread without safepoint code notice
 // of this thread since it is removed from the queue.
 p->set_terminated_value();
 } // unlock Threads_lock
 // Since Events::log uses a lock, we grab it outside the Threads_lock
-Events::log("Thread exited: " INTPTR_FORMAT, p);
+Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
 }
 // Threads_lock must be held when this is called (or must be called during a safepoint)
 bool Threads::includes(JavaThread* p) {
 assert(Threads_lock->is_locked(), "sanity check");

Mercurial > hg > truffle

comparison src/share/vm/runtime/thread.cpp @ 4970:33df1aeaebbf