< prev index next >

src/hotspot/share/runtime/safepoint.cpp

Print this page
rev 57232 : v2.00 -> v2.08 (CR8/v2.08/11-for-jdk14) patches combined into one; merge with jdk-14+25 snapshot; merge with jdk-14+26 snapshot.


 506   _wait_barrier->disarm();
 507 }
 508 
 509 // Wake up all threads, so they are ready to resume execution after the safepoint
 510 // operation has been carried out
 511 void SafepointSynchronize::end() {
 512   assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
 513   EventSafepointEnd event;
 514   assert(Thread::current()->is_VM_thread(), "Only VM thread can execute a safepoint");
 515 
 516   disarm_safepoint();
 517 
 518   Universe::heap()->safepoint_synchronize_end();
 519 
 520   SafepointTracing::end();
 521 
 522   post_safepoint_end_event(event, safepoint_id());
 523 }
 524 
 525 bool SafepointSynchronize::is_cleanup_needed() {
 526   // Need a safepoint if there are many monitors to deflate.
 527   if (ObjectSynchronizer::is_cleanup_needed()) return true;

 528   // Need a safepoint if some inline cache buffers is non-empty
 529   if (!InlineCacheBuffer::is_empty()) return true;
 530   if (StringTable::needs_rehashing()) return true;
 531   if (SymbolTable::needs_rehashing()) return true;
 532   return false;
 533 }
 534 
 535 bool SafepointSynchronize::is_forced_cleanup_needed() {
 536   return ObjectSynchronizer::needs_monitor_scavenge();
 537 }
 538 
 539 class ParallelSPCleanupThreadClosure : public ThreadClosure {
 540 private:
 541   CodeBlobClosure* _nmethod_cl;
 542   DeflateMonitorCounters* _counters;
 543 
 544 public:
 545   ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
 546     _nmethod_cl(UseCodeAging ? NMethodSweeper::prepare_reset_hotness_counters() : NULL),
 547     _counters(counters) {}
 548 
 549   void do_thread(Thread* thread) {




 550     ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
 551     if (_nmethod_cl != NULL && thread->is_Java_thread() &&
 552         ! thread->is_Code_cache_sweeper_thread()) {
 553       JavaThread* jt = (JavaThread*) thread;
 554       jt->nmethods_do(_nmethod_cl);
 555     }
 556   }
 557 };
 558 
 559 class ParallelSPCleanupTask : public AbstractGangTask {
 560 private:
 561   SubTasksDone _subtasks;
 562   ParallelSPCleanupThreadClosure _cleanup_threads_cl;
 563   uint _num_workers;
 564   DeflateMonitorCounters* _counters;
 565 public:
 566   ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
 567     AbstractGangTask("Parallel Safepoint Cleanup"),
 568     _subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
 569     _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
 570     _num_workers(num_workers),
 571     _counters(counters) {}
 572 
 573   void work(uint worker_id) {
 574     uint64_t safepoint_id = SafepointSynchronize::safepoint_id();
 575     // All threads deflate monitors and mark nmethods (if necessary).
 576     Threads::possibly_parallel_threads_do(true, &_cleanup_threads_cl);
 577 
 578     if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
 579       const char* name = "deflating global idle monitors";
 580       EventSafepointCleanupTask event;
 581       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 582       ObjectSynchronizer::deflate_idle_monitors(_counters);




 583 
 584       post_safepoint_cleanup_task_event(event, safepoint_id, name);
 585     }
 586 
 587     if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
 588       const char* name = "updating inline caches";
 589       EventSafepointCleanupTask event;
 590       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 591       InlineCacheBuffer::update_inline_caches();
 592 
 593       post_safepoint_cleanup_task_event(event, safepoint_id, name);
 594     }
 595 
 596     if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
 597       const char* name = "compilation policy safepoint handler";
 598       EventSafepointCleanupTask event;
 599       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 600       CompilationPolicy::policy()->do_safepoint_work();
 601 
 602       post_safepoint_cleanup_task_event(event, safepoint_id, name);




 506   _wait_barrier->disarm();
 507 }
 508 
 509 // Wake up all threads, so they are ready to resume execution after the safepoint
 510 // operation has been carried out
 511 void SafepointSynchronize::end() {
 512   assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
 513   EventSafepointEnd event;
 514   assert(Thread::current()->is_VM_thread(), "Only VM thread can execute a safepoint");
 515 
 516   disarm_safepoint();
 517 
 518   Universe::heap()->safepoint_synchronize_end();
 519 
 520   SafepointTracing::end();
 521 
 522   post_safepoint_end_event(event, safepoint_id());
 523 }
 524 
 525 bool SafepointSynchronize::is_cleanup_needed() {
 526   // Need a cleanup safepoint if there are too many monitors in use
 527   // and the monitor deflation needs to be done at a safepoint.
 528   if (ObjectSynchronizer::is_safepoint_deflation_needed()) return true;
 529   // Need a safepoint if some inline cache buffers is non-empty
 530   if (!InlineCacheBuffer::is_empty()) return true;
 531   if (StringTable::needs_rehashing()) return true;
 532   if (SymbolTable::needs_rehashing()) return true;
 533   return false;
 534 }
 535 
 536 bool SafepointSynchronize::is_forced_cleanup_needed() {
 537   return ObjectSynchronizer::needs_monitor_scavenge();
 538 }
 539 
 540 class ParallelSPCleanupThreadClosure : public ThreadClosure {
 541 private:
 542   CodeBlobClosure* _nmethod_cl;
 543   DeflateMonitorCounters* _counters;
 544 
 545 public:
 546   ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
 547     _nmethod_cl(UseCodeAging ? NMethodSweeper::prepare_reset_hotness_counters() : NULL),
 548     _counters(counters) {}
 549 
 550   void do_thread(Thread* thread) {
 551     // deflate_thread_local_monitors() handles or requests deflation of
 552     // this thread's idle monitors. If !AsyncDeflateIdleMonitors or if
 553     // there is a special cleanup request, deflation is handled now.
 554     // Otherwise, async deflation is requested via a flag.
 555     ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
 556     if (_nmethod_cl != NULL && thread->is_Java_thread() &&
 557         ! thread->is_Code_cache_sweeper_thread()) {
 558       JavaThread* jt = (JavaThread*) thread;
 559       jt->nmethods_do(_nmethod_cl);
 560     }
 561   }
 562 };
 563 
 564 class ParallelSPCleanupTask : public AbstractGangTask {
 565 private:
 566   SubTasksDone _subtasks;
 567   ParallelSPCleanupThreadClosure _cleanup_threads_cl;
 568   uint _num_workers;
 569   DeflateMonitorCounters* _counters;
 570 public:
 571   ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
 572     AbstractGangTask("Parallel Safepoint Cleanup"),
 573     _subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
 574     _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
 575     _num_workers(num_workers),
 576     _counters(counters) {}
 577 
 578   void work(uint worker_id) {
 579     uint64_t safepoint_id = SafepointSynchronize::safepoint_id();
 580     // All threads deflate monitors and mark nmethods (if necessary).
 581     Threads::possibly_parallel_threads_do(true, &_cleanup_threads_cl);
 582 
 583     if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
 584       const char* name = "deflating global idle monitors";
 585       EventSafepointCleanupTask event;
 586       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 587       // AsyncDeflateIdleMonitors only uses DeflateMonitorCounters
 588       // when a special cleanup has been requested.
 589       // Note: This logging output will include global idle monitor
 590       // elapsed times, but not global idle monitor deflation count.
 591       ObjectSynchronizer::do_safepoint_work(_counters);
 592 
 593       post_safepoint_cleanup_task_event(event, safepoint_id, name);
 594     }
 595 
 596     if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
 597       const char* name = "updating inline caches";
 598       EventSafepointCleanupTask event;
 599       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 600       InlineCacheBuffer::update_inline_caches();
 601 
 602       post_safepoint_cleanup_task_event(event, safepoint_id, name);
 603     }
 604 
 605     if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
 606       const char* name = "compilation policy safepoint handler";
 607       EventSafepointCleanupTask event;
 608       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
 609       CompilationPolicy::policy()->do_safepoint_work();
 610 
 611       post_safepoint_cleanup_task_event(event, safepoint_id, name);


< prev index next >