< prev index next >
src/share/vm/runtime/thread.cpp
Print this page
*** 94,103 ****
--- 94,104 ----
#endif
#ifdef TARGET_OS_FAMILY_bsd
# include "os_bsd.inline.hpp"
#endif
#if INCLUDE_ALL_GCS
+ #include "gc_implementation/shenandoah/shenandoahControlThread.hpp"
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
#include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
#include "gc_implementation/parallelScavenge/pcTasks.hpp"
#endif // INCLUDE_ALL_GCS
#ifdef COMPILER1
*** 301,312 ****
--- 302,347 ----
assert(this == _real_malloc_address ||
this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),
"bug in forced alignment of thread objects");
}
#endif /* ASSERT */
+
+ _oom_during_evac = 0;
+ #if INCLUDE_ALL_GCS
+ _gc_state = _gc_state_global;
+ _worker_id = (uint)(-1); // Actually, ShenandoahWorkerSession::INVALID_WORKER_ID, but avoid dependencies.
+ _force_satb_flush = false;
+ _paced_time = 0;
+ #endif
+ }
+
+ void Thread::set_oom_during_evac(bool oom) {
+ if (oom) {
+ _oom_during_evac |= 1;
+ } else {
+ _oom_during_evac &= ~1;
+ }
+ }
+
+ bool Thread::is_oom_during_evac() const {
+ return (_oom_during_evac & 1) == 1;
}
+ #ifdef ASSERT
+ void Thread::set_evac_allowed(bool evac_allowed) {
+ if (evac_allowed) {
+ _oom_during_evac |= 2;
+ } else {
+ _oom_during_evac &= ~2;
+ }
+ }
+
+ bool Thread::is_evac_allowed() const {
+ return (_oom_during_evac & 2) == 2;
+ }
+ #endif
+
void Thread::initialize_thread_local_storage() {
// Note: Make sure this method only calls
// non-blocking operations. Otherwise, it might not work
// with the thread-startup/safepoint interaction.
*** 1506,1515 ****
--- 1541,1551 ----
}
#if INCLUDE_ALL_GCS
SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
+ char Thread::_gc_state_global = 0;
#endif // INCLUDE_ALL_GCS
JavaThread::JavaThread(bool is_attaching_via_jni) :
Thread()
#if INCLUDE_ALL_GCS
*** 1909,1921 ****
#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 // 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);
}
--- 1945,1960 ----
#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 || (UseShenandoahGC)) {
flush_barrier_queues();
}
+ if (UseShenandoahGC && UseTLAB && gclab().is_initialized()) {
+ gclab().make_parsable(true);
+ }
#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);
}
*** 1945,1954 ****
--- 1984,2014 ----
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");
+
+ _gc_state = _gc_state_global;
+ }
+
+ void JavaThread::set_gc_state(char in_prog) {
+ _gc_state = in_prog;
+ }
+
+ void JavaThread::set_gc_state_all_threads(char in_prog) {
+ assert_locked_or_safepoint(Threads_lock);
+ _gc_state_global = in_prog;
+ for (JavaThread* t = Threads::first(); t != NULL; t = t->next()) {
+ t->set_gc_state(in_prog);
+ }
+ }
+
+ void JavaThread::set_force_satb_flush_all_threads(bool value) {
+ assert_locked_or_safepoint(Threads_lock);
+ for (JavaThread* t = Threads::first(); t != NULL; t = t->next()) {
+ t->set_force_satb_flush(value);
+ }
}
#endif // INCLUDE_ALL_GCS
void JavaThread::cleanup_failed_attach_current_thread() {
if (get_thread_profiler() != NULL) {
*** 1975,1987 ****
if (UseTLAB) {
tlab().make_parsable(true); // retire TLAB, if any
}
#if INCLUDE_ALL_GCS
! if (UseG1GC) {
flush_barrier_queues();
}
#endif // INCLUDE_ALL_GCS
Threads::remove(this);
delete this;
}
--- 2035,2050 ----
if (UseTLAB) {
tlab().make_parsable(true); // retire TLAB, if any
}
#if INCLUDE_ALL_GCS
! if (UseG1GC || (UseShenandoahGC)) {
flush_barrier_queues();
}
+ if (UseShenandoahGC && UseTLAB && gclab().is_initialized()) {
+ gclab().make_parsable(true);
+ }
#endif // INCLUDE_ALL_GCS
Threads::remove(this);
delete this;
}
*** 3282,3291 ****
--- 3345,3361 ----
#endif
// All JavaThreads
#define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next())
+ void Threads::java_threads_do(ThreadClosure* tc) {
+ assert_locked_or_safepoint(Threads_lock);
+ ALL_JAVA_THREADS(p) {
+ tc->do_thread(p);
+ }
+ }
+
// All JavaThreads + all non-JavaThreads (i.e., every thread in the system)
void Threads::threads_do(ThreadClosure* tc) {
assert_locked_or_safepoint(Threads_lock);
// ALL_JAVA_THREADS iterates through all JavaThreads
ALL_JAVA_THREADS(p) {
*** 3598,3610 ****
#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) {
ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD);
} else {
ConcurrentMarkThread::makeSurrogateLockerThread(THREAD);
}
if (HAS_PENDING_EXCEPTION) {
vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
--- 3668,3682 ----
#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 || UseShenandoahGC) {
if (UseConcMarkSweepGC) {
ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD);
+ } else if (UseShenandoahGC) {
+ ShenandoahControlThread::makeSurrogateLockerThread(THREAD);
} else {
ConcurrentMarkThread::makeSurrogateLockerThread(THREAD);
}
if (HAS_PENDING_EXCEPTION) {
vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
*** 4193,4203 ****
// turn off parallelism in process_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, cld_f, cf);
}
--- 4265,4276 ----
// turn off parallelism in process_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()
! || UseShenandoahGC), "Mismatch");
int cp = SharedHeap::heap()->strong_roots_parity();
ALL_JAVA_THREADS(p) {
if (p->claim_oops_do(is_par, cp)) {
p->oops_do(f, cld_f, cf);
}
< prev index next >