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);
|