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

comparison src/share/vm/runtime/thread.cpp @ 8124:5fc51c1ecdeb

Merge.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Tue, 05 Mar 2013 23:44:54 +0100
parents	c6c72de0537e b8d5d7a6c94c
children	b8f261ba79c6

comparison

equal deleted inserted replaced

-:a413bcd552a4
+:5fc51c1ecdeb
 /*
-* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2013, 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.
 #include "trace/traceEventTypes.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/preserveException.hpp"
+#include "utilities/macros.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 # include "os_linux.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_solaris
 # include "os_solaris.inline.hpp"
 # include "os_windows.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_bsd
 # include "os_bsd.inline.hpp"
 #endif
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
 #include "gc_implementation/parallelScavenge/pcTasks.hpp"
-#endif
+#endif // INCLUDE_ALL_GCS
 #ifdef COMPILER1
 #include "c1/c1_Compiler.hpp"
 #endif
 #ifdef COMPILER2
 #include "opto/c2compiler.hpp"
 _popframe_preserved_args_size = 0;
 pd_initialize();
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
 DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
-#endif // !SERIALGC
+#endif // INCLUDE_ALL_GCS
 JavaThread::JavaThread(bool is_attaching_via_jni) :
 Thread()
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 , _satb_mark_queue(&_satb_mark_queue_set),
 _dirty_card_queue(&_dirty_card_queue_set)
-#endif // !SERIALGC
+#endif // INCLUDE_ALL_GCS
 {
 initialize();
 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");
+assert(deferred_card_mark().is_empty(), "Default MemRegion ctor");
 _safepoint_visible = false;
 }
 bool JavaThread::reguard_stack(address cur_sp) {
 if (_stack_guard_state != stack_guard_yellow_disabled) {
 // Remove this ifdef when C1 is ported to the compiler interface.
 static void compiler_thread_entry(JavaThread* thread, TRAPS);
 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
 Thread()
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 , _satb_mark_queue(&_satb_mark_queue_set),
 _dirty_card_queue(&_dirty_card_queue_set)
-#endif // !SERIALGC
+#endif // INCLUDE_ALL_GCS
 {
 if (TraceThreadEvents) {
 tty->print_cr("creating thread %p", this);
 }
 initialize();
 if (JvmtiEnv::environments_might_exist()) {
 JvmtiExport::cleanup_thread(this);
 }
-#ifndef SERIALGC
+// We must flush any deferred card marks before removing a thread from
-// We must flush G1-related buffers before removing a thread from
 // the list of active threads.
+Universe::heap()->flush_deferred_store_barrier(this);
+assert(deferred_card_mark().is_empty(), "Should have been flushed");
+#if INCLUDE_ALL_GCS
+// We must flush the G1-related buffers before removing a thread
+// from the list of active threads. We must do this after any deferred
+// card marks have been flushed (above) so that any entries that are
+// added to the thread's dirty card queue as a result are not lost.
 if (UseG1GC) {
 flush_barrier_queues();
 }
-#endif
+#endif // INCLUDE_ALL_GCS
 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
 Threads::remove(this);
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 // Flush G1-related queues.
 void JavaThread::flush_barrier_queues() {
 satb_mark_queue().flush();
 dirty_card_queue().flush();
 }
 DirtyCardQueue& dirty_queue = dirty_card_queue();
 // The dirty card queue should have been constructed with its
 // active field set to true.
 assert(dirty_queue.is_active(), "dirty card queue should be active");
 }
-#endif // !SERIALGC
+#endif // INCLUDE_ALL_GCS
 void JavaThread::cleanup_failed_attach_current_thread() {
 if (get_thread_profiler() != NULL) {
 get_thread_profiler()->disengage();
 ResourceMark rm;
 if (UseTLAB) {
 tlab().make_parsable(true);  // retire TLAB, if any
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 if (UseG1GC) {
 flush_barrier_queues();
 }
-#endif
+#endif // INCLUDE_ALL_GCS
 Threads::remove(this);
 delete this;
 }
 SystemDictionary::compute_java_system_loader(THREAD);
 if (HAS_PENDING_EXCEPTION) {
 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 // Support for ConcurrentMarkSweep. This should be cleaned up
 // and better encapsulated. The ugly nested if test would go away
 // once things are properly refactored. XXX YSR
 if (UseConcMarkSweepGC || UseG1GC) {
 if (UseConcMarkSweepGC) {
 }
 if (HAS_PENDING_EXCEPTION) {
 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
 }
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 // Always call even when there are not JVMTI environments yet, since environments
 // may be attached late and JVMTI must track phases of VM execution
 JvmtiExport::enter_live_phase();
 // Try to load the agent from the standard dll directory
 if (os::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(),
 name)) {
 library = os::dll_load(buffer, ebuf, sizeof ebuf);
 }
-#ifdef KERNEL
-// Download instrument dll
-if (library == NULL && strcmp(name, "instrument") == 0) {
-char *props = Arguments::get_kernel_properties();
-char *home  = Arguments::get_java_home();
-const char *fmt   = "%s/bin/java %s -Dkernel.background.download=false"
-" sun.jkernel.DownloadManager -download client_jvm";
-size_t length = strlen(props) + strlen(home) + strlen(fmt) + 1;
-char *cmd = NEW_C_HEAP_ARRAY(char, length, mtThread);
-jio_snprintf(cmd, length, fmt, home, props);
-int status = os::fork_and_exec(cmd);
-FreeHeap(props);
-if (status == -1) {
-warning(cmd);
-vm_exit_during_initialization("fork_and_exec failed: %s",
-strerror(errno));
-}
-FREE_C_HEAP_ARRAY(char, cmd, mtThread);
-// when this comes back the instrument.dll should be where it belongs.
-library = os::dll_load(buffer, ebuf, sizeof ebuf);
-}
-#endif // KERNEL
 if (library == NULL) { // Try the local directory
 char ns[1] = {0};
 if (os::dll_build_name(buffer, sizeof(buffer), ns, name)) {
 library = os::dll_load(buffer, ebuf, sizeof ebuf);
 }
 if (vmt->claim_oops_do(is_par, cp)) {
 vmt->oops_do(f, cld_f, cf);
 }
 }
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 // Used by ParallelScavenge
 void Threads::create_thread_roots_tasks(GCTaskQueue* q) {
 ALL_JAVA_THREADS(p) {
 q->enqueue(new ThreadRootsTask(p));
 }
 ALL_JAVA_THREADS(p) {
 q->enqueue(new ThreadRootsMarkingTask(p));
 }
 q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread()));
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 void Threads::nmethods_do(CodeBlobClosure* cf) {
 ALL_JAVA_THREADS(p) {
 p->nmethods_do(cf);
 }
 Abstract_VM_Version::vm_release(),
 Abstract_VM_Version::vm_info_string()
 );
 st->cr();
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 // Dump concurrent locks
 ConcurrentLocksDump concurrent_locks;
 if (print_concurrent_locks) {
 concurrent_locks.dump_at_safepoint();
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 ALL_JAVA_THREADS(p) {
 ResourceMark rm;
 p->print_on(st);
 if (print_stacks) {
 } else {
 p->print_stack_on(st);
 }
 }
 st->cr();
-#ifndef SERIALGC
+#if INCLUDE_ALL_GCS
 if (print_concurrent_locks) {
 concurrent_locks.print_locks_on(p, st);
 }
-#endif // SERIALGC
+#endif // INCLUDE_ALL_GCS
 }
 VMThread::vm_thread()->print_on(st);
 st->cr();
 Universe::heap()->print_gc_threads_on(st);

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/thread.cpp @ 8124:5fc51c1ecdeb