jdk8-mips64-public/hotspot: comparison src/share/vm/runtime/thread.cpp

-:454d7cc622ab
+:3c9bc17b9403
 #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 {
 // 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
+#if INCLUDE_ALL_GCS
 // We must flush G1-related buffers before removing a thread from
 // the list of active threads.
 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();
 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 > jdk8-mips64-public > hotspot / file comparison

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

src/share/vm/runtime/thread.cpp