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

equal deleted inserted replaced

-:c84d0cce090e
+:d65d53a0ecc7
 #include "code/scopeDesc.hpp"
 #include "compiler/compileBroker.hpp"
 #include "compiler/compileTask.hpp"
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/gcLocker.inline.hpp"
+#include "gc/shared/referencePendingListLocker.hpp"
 #include "gc/shared/workgroup.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "jvmtifiles/jvmtiEnv.hpp"
 #include "logging/log.hpp"
 #include "logging/logConfiguration.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/oopFactory.hpp"
+#include "memory/resourceArea.hpp"
 #include "memory/universe.inline.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "runtime/init.hpp"
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/java.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/jniPeriodicChecker.hpp"
-#include "runtime/logTimer.hpp"
+#include "runtime/timerTrace.hpp"
 #include "runtime/memprofiler.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/objectMonitor.hpp"
 #include "runtime/orderAccess.inline.hpp"
 #include "runtime/osThread.hpp"
 #ifndef USE_LIBRARY_BASED_TLS_ONLY
 // Current thread is maintained as a thread-local variable
 THREAD_LOCAL_DECL Thread* Thread::_thr_current = NULL;
 #endif
 // Class hierarchy
 // - Thread
 //   - VMThread
 //   - WatcherThread
 //   - ConcurrentMarkSweepThread
 // Do oop for ThreadShadow
 f->do_oop((oop*)&_pending_exception);
 handle_area()->oops_do(f);
 }
-void Thread::nmethods_do(CodeBlobClosure* cf) {
-// no nmethods in a generic thread...
-}
 void Thread::metadata_handles_do(void f(Metadata*)) {
 // Only walk the Handles in Thread.
 if (metadata_handles() != NULL) {
 for (int i = 0; i< metadata_handles()->length(); i++) {
 f(metadata_handles()->at(i));
 // We cannot call Exceptions::_throw(...) here because we cannot block
 set_pending_exception(_pending_async_exception, __FILE__, __LINE__);
 if (log_is_enabled(Info, exceptions)) {
 ResourceMark rm;
-outputStream* logstream = LogHandle(exceptions)::info_stream();
+outputStream* logstream = Log(exceptions)::info_stream();
 logstream->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", p2i(this));
 if (has_last_Java_frame()) {
 frame f = last_frame();
 logstream->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", p2i(f.pc()), p2i(f.sp()));
 }
 jvmti_thread_state()->oops_do(f);
 }
 }
 void JavaThread::nmethods_do(CodeBlobClosure* cf) {
-Thread::nmethods_do(cf);  // (super method is a no-op)
 assert((!has_last_Java_frame() && java_call_counter() == 0) ||
 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
 if (has_last_Java_frame()) {
 // Traverse the execution stack
 }
 #endif // PRODUCT
 // Called by Threads::print() for VM_PrintThreads operation
 void JavaThread::print_on(outputStream *st) const {
-st->print("\"%s\" ", get_thread_name());
+st->print_raw("\"");
+st->print_raw(get_thread_name());
+st->print_raw("\" ");
 oop thread_oop = threadObj();
 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));
 // Create sweeper thread
 CodeCacheSweeperThread::CodeCacheSweeperThread()
 : JavaThread(&sweeper_thread_entry) {
 _scanned_nmethod = NULL;
 }
 void CodeCacheSweeperThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
 JavaThread::oops_do(f, cld_f, cf);
+if (_scanned_nmethod != NULL && cf != NULL) {
+// Safepoints can occur when the sweeper is scanning an nmethod so
+// process it here to make sure it isn't unloaded in the middle of
+// a scan.
+cf->do_code_blob(_scanned_nmethod);
+}
+}
+void CodeCacheSweeperThread::nmethods_do(CodeBlobClosure* cf) {
+JavaThread::nmethods_do(cf);
 if (_scanned_nmethod != NULL && cf != NULL) {
 // Safepoints can occur when the sweeper is scanning an nmethod so
 // process it here to make sure it isn't unloaded in the middle of
 // a scan.
 cf->do_code_blob(_scanned_nmethod);
 JavaCalls::call_static(&result, klass, vmSymbols::initPhase3_name(),
 vmSymbols::void_method_signature(), CHECK);
 }
 void Threads::initialize_java_lang_classes(JavaThread* main_thread, TRAPS) {
-TraceStartupTime timer("Initialize java.lang classes");
+TraceTime timer("Initialize java.lang classes", TRACETIME_LOG(Info, startuptime));
 if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
 create_vm_init_libraries();
 }
 initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK);
 initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK);
 }
 void Threads::initialize_jsr292_core_classes(TRAPS) {
-TraceStartupTime timer("Initialize java.lang.invoke classes");
+TraceTime timer("Initialize java.lang.invoke classes", TRACETIME_LOG(Info, startuptime));
 initialize_class(vmSymbols::java_lang_invoke_MethodHandle(), CHECK);
 initialize_class(vmSymbols::java_lang_invoke_MemberName(), CHECK);
 initialize_class(vmSymbols::java_lang_invoke_MethodHandleNatives(), CHECK);
 }
 }
 HOTSPOT_VM_INIT_BEGIN();
 // Timing (must come after argument parsing)
-TraceStartupTime timer("Create VM");
+TraceTime timer("Create VM", TRACETIME_LOG(Info, startuptime));
 // Initialize the os module after parsing the args
 jint os_init_2_result = os::init_2();
 if (os_init_2_result != JNI_OK) return os_init_2_result;
 // 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();
 // Create the VMThread
-{ TraceStartupTime timer("Start VMThread");
+{ TraceTime timer("Start VMThread", TRACETIME_LOG(Info, startuptime));
 VMThread::create();
 Thread* vmthread = VMThread::vm_thread();
 if (!os::create_thread(vmthread, os::vm_thread)) {
 // 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
 // anymore. We call vm_exit_during_initialization directly instead.
-#if INCLUDE_ALL_GCS
+// Initialize reference pending list locker
-// Support for ConcurrentMarkSweep. This should be cleaned up
+bool needs_locker_thread = Universe::heap()->needs_reference_pending_list_locker_thread();
-// and better encapsulated. The ugly nested if test would go away
+ReferencePendingListLocker::initialize(needs_locker_thread, CHECK_JNI_ERR);
-// once things are properly refactored. XXX YSR
-if (UseConcMarkSweepGC || UseG1GC) {
-if (UseConcMarkSweepGC) {
-ConcurrentMarkSweepThread::makeSurrogateLockerThread(CHECK_JNI_ERR);
-} else {
-ConcurrentMarkThread::makeSurrogateLockerThread(CHECK_JNI_ERR);
-}
-}
-#endif // INCLUDE_ALL_GCS
 // Signal Dispatcher needs to be started before VMInit event is posted
 os::signal_init();
 // Start Attach Listener if +StartAttachListener or it can't be started lazily
 }
 #endif // INCLUDE_ALL_GCS
 void Threads::nmethods_do(CodeBlobClosure* cf) {
 ALL_JAVA_THREADS(p) {
-p->nmethods_do(cf);
+// This is used by the code cache sweeper to mark nmethods that are active
-}
+// on the stack of a Java thread. Ignore the sweeper thread itself to avoid
-VMThread::vm_thread()->nmethods_do(cf);
+// marking CodeCacheSweeperThread::_scanned_nmethod as active.
+if(!p->is_Code_cache_sweeper_thread()) {
+p->nmethods_do(cf);
+}
+}
 }
 void Threads::metadata_do(void f(Metadata*)) {
 ALL_JAVA_THREADS(p) {
 p->metadata_do(f);

changeset 37297	d65d53a0ecc7
parent 36850	ada6dcfa50dc
parent 37296	613278eb2a1e
child 37477	0ca0b7388bb6