< prev index next >

src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.cpp

Print this page
rev 53870 : imported patch shade-shenandoah-ptrqueue
rev 53871 : [mq]: shenandoah_merge_attach


 320     obj = resolve_forwarded(obj);
 321   }
 322   return obj;
 323 }
 324 
 325 void ShenandoahBarrierSet::keep_alive_barrier(oop obj) {
 326   if (ShenandoahKeepAliveBarrier && _heap->is_concurrent_mark_in_progress()) {
 327     enqueue(obj);
 328   }
 329 }
 330 
 331 void ShenandoahBarrierSet::enqueue(oop obj) {
 332   shenandoah_assert_not_forwarded_if(NULL, obj, _heap->is_concurrent_traversal_in_progress());
 333   if (!_satb_mark_queue_set.is_active()) return;
 334 
 335   // Filter marked objects before hitting the SATB queues. The same predicate would
 336   // be used by SATBMQ::filter to eliminate already marked objects downstream, but
 337   // filtering here helps to avoid wasteful SATB queueing work to begin with.
 338   if (!_heap->requires_marking<false>(obj)) return;
 339 
 340   Thread* thr = Thread::current();
 341   if (thr->is_Java_thread()) {
 342     ShenandoahThreadLocalData::satb_mark_queue(thr).enqueue(obj);
 343   } else {
 344     MutexLockerEx x(Shared_SATB_Q_lock, Mutex::_no_safepoint_check_flag);
 345     _satb_mark_queue_set.shared_satb_queue()->enqueue(obj);
 346   }
 347 }
 348 
 349 void ShenandoahBarrierSet::on_thread_create(Thread* thread) {
 350   // Create thread local data
 351   ShenandoahThreadLocalData::create(thread);
 352 }
 353 
 354 void ShenandoahBarrierSet::on_thread_destroy(Thread* thread) {
 355   // Destroy thread local data
 356   ShenandoahThreadLocalData::destroy(thread);
 357 }
 358 
 359 void ShenandoahBarrierSet::on_thread_attach(JavaThread* thread) {
 360   assert(!SafepointSynchronize::is_at_safepoint(), "We should not be at a safepoint");
 361   assert(!ShenandoahThreadLocalData::satb_mark_queue(thread).is_active(), "SATB queue should not be active");
 362   assert(ShenandoahThreadLocalData::satb_mark_queue(thread).is_empty(), "SATB queue should be empty");
 363   if (ShenandoahBarrierSet::satb_mark_queue_set().is_active()) {
 364     ShenandoahThreadLocalData::satb_mark_queue(thread).set_active(true);
 365   }

 366   ShenandoahThreadLocalData::set_gc_state(thread, _heap->gc_state());
 367   ShenandoahThreadLocalData::initialize_gclab(thread);

 368 }
 369 
 370 void ShenandoahBarrierSet::on_thread_detach(JavaThread* thread) {
 371   ShenandoahThreadLocalData::satb_mark_queue(thread).flush();


 372   PLAB* gclab = ShenandoahThreadLocalData::gclab(thread);
 373   if (gclab != NULL) {
 374     gclab->retire();

 375   }
 376 }


 320     obj = resolve_forwarded(obj);
 321   }
 322   return obj;
 323 }
 324 
 325 void ShenandoahBarrierSet::keep_alive_barrier(oop obj) {
 326   if (ShenandoahKeepAliveBarrier && _heap->is_concurrent_mark_in_progress()) {
 327     enqueue(obj);
 328   }
 329 }
 330 
 331 void ShenandoahBarrierSet::enqueue(oop obj) {
 332   shenandoah_assert_not_forwarded_if(NULL, obj, _heap->is_concurrent_traversal_in_progress());
 333   if (!_satb_mark_queue_set.is_active()) return;
 334 
 335   // Filter marked objects before hitting the SATB queues. The same predicate would
 336   // be used by SATBMQ::filter to eliminate already marked objects downstream, but
 337   // filtering here helps to avoid wasteful SATB queueing work to begin with.
 338   if (!_heap->requires_marking<false>(obj)) return;
 339 
 340   ShenandoahThreadLocalData::satb_mark_queue(Thread::current()).enqueue(obj);






 341 }
 342 
 343 void ShenandoahBarrierSet::on_thread_create(Thread* thread) {
 344   // Create thread local data
 345   ShenandoahThreadLocalData::create(thread);
 346 }
 347 
 348 void ShenandoahBarrierSet::on_thread_destroy(Thread* thread) {
 349   // Destroy thread local data
 350   ShenandoahThreadLocalData::destroy(thread);
 351 }
 352 
 353 void ShenandoahBarrierSet::on_thread_attach(Thread *thread) {
 354   assert(!thread->is_Java_thread() || !SafepointSynchronize::is_at_safepoint(),
 355          "We should not be at a safepoint");
 356   SATBMarkQueue& queue = ShenandoahThreadLocalData::satb_mark_queue(thread);
 357   assert(!queue.is_active(), "SATB queue should not be active");
 358   assert( queue.is_empty(),  "SATB queue should be empty");
 359   queue.set_active(_satb_mark_queue_set.is_active());
 360   if (thread->is_Java_thread()) {
 361     ShenandoahThreadLocalData::set_gc_state(thread, _heap->gc_state());
 362     ShenandoahThreadLocalData::initialize_gclab(thread);
 363   }
 364 }
 365 
 366 void ShenandoahBarrierSet::on_thread_detach(Thread *thread) {
 367   SATBMarkQueue& queue = ShenandoahThreadLocalData::satb_mark_queue(thread);
 368   queue.flush();
 369   if (thread->is_Java_thread()) {
 370     PLAB* gclab = ShenandoahThreadLocalData::gclab(thread);
 371     if (gclab != NULL) {
 372       gclab->retire();
 373     }
 374   }
 375 }
< prev index next >