55 #include "runtime/synchronizer.hpp"
56 #include "runtime/thread.inline.hpp"
57 #include "runtime/timerTrace.hpp"
58 #include "services/runtimeService.hpp"
59 #include "trace/tracing.hpp"
60 #include "trace/traceMacros.hpp"
61 #include "utilities/events.hpp"
62 #include "utilities/macros.hpp"
63 #if INCLUDE_ALL_GCS
64 #include "gc/shenandoah/shenandoahConcurrentThread.hpp"
65 #include "gc/cms/concurrentMarkSweepThread.hpp"
66 #include "gc/g1/suspendibleThreadSet.hpp"
67 #endif // INCLUDE_ALL_GCS
68 #ifdef COMPILER1
69 #include "c1/c1_globals.hpp"
70 #endif
71
72 // --------------------------------------------------------------------------------------------------
73 // Implementation of Safepoint begin/end
74
75 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;
76 volatile int SafepointSynchronize::_waiting_to_block = 0;
77 volatile int SafepointSynchronize::_safepoint_counter = 0;
78 int SafepointSynchronize::_current_jni_active_count = 0;
79 long SafepointSynchronize::_end_of_last_safepoint = 0;
80 static volatile int PageArmed = 0 ; // safepoint polling page is RO|RW vs PROT_NONE
81 static volatile int TryingToBlock = 0 ; // proximate value -- for advisory use only
82 static bool timeout_error_printed = false;
83
84 // Roll all threads forward to a safepoint and suspend them all
85 void SafepointSynchronize::begin() {
86 EventSafepointBegin begin_event;
87 Thread* myThread = Thread::current();
88 assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint");
89
90 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {
91 _safepoint_begin_time = os::javaTimeNanos();
92 _ts_of_current_safepoint = tty->time_stamp().seconds();
93 }
94
526 event.commit();
527 }
528 }
529
530 bool SafepointSynchronize::is_cleanup_needed() {
531 // Need a safepoint if some inline cache buffers is non-empty
532 if (!InlineCacheBuffer::is_empty()) return true;
533 return false;
534 }
535
536 static void event_safepoint_cleanup_task_commit(EventSafepointCleanupTask& event, const char* name) {
537 if (event.should_commit()) {
538 event.set_safepointId(SafepointSynchronize::safepoint_counter());
539 event.set_name(name);
540 event.commit();
541 }
542 }
543
544 // Various cleaning tasks that should be done periodically at safepoints
545 void SafepointSynchronize::do_cleanup_tasks() {
546 {
547 const char* name = "deflating idle monitors";
548 EventSafepointCleanupTask event;
549 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
550 ObjectSynchronizer::deflate_idle_monitors();
551 event_safepoint_cleanup_task_commit(event, name);
552 }
553
554 {
555 const char* name = "updating inline caches";
556 EventSafepointCleanupTask event;
557 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
558 InlineCacheBuffer::update_inline_caches();
559 event_safepoint_cleanup_task_commit(event, name);
560 }
561 {
562 const char* name = "compilation policy safepoint handler";
563 EventSafepointCleanupTask event;
564 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));
565 CompilationPolicy::policy()->do_safepoint_work();
566 event_safepoint_cleanup_task_commit(event, name);
567 }
568
569 {
570 const char* name = "mark nmethods";
571 EventSafepointCleanupTask event;
572 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
573 NMethodSweeper::mark_active_nmethods();
574 event_safepoint_cleanup_task_commit(event, name);
575 }
576
577 if (SymbolTable::needs_rehashing()) {
578 const char* name = "rehashing symbol table";
579 EventSafepointCleanupTask event;
580 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
581 SymbolTable::rehash_table();
582 event_safepoint_cleanup_task_commit(event, name);
583 }
584
585 if (StringTable::needs_rehashing()) {
586 const char* name = "rehashing string table";
587 EventSafepointCleanupTask event;
588 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
589 StringTable::rehash_table();
590 event_safepoint_cleanup_task_commit(event, name);
591 }
592
593 {
594 // CMS delays purging the CLDG until the beginning of the next safepoint and to
595 // make sure concurrent sweep is done
596 const char* name = "purging class loader data graph";
597 EventSafepointCleanupTask event;
598 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
599 ClassLoaderDataGraph::purge_if_needed();
600 event_safepoint_cleanup_task_commit(event, name);
601 }
602 }
603
604
605 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {
606 switch(state) {
607 case _thread_in_native:
608 // native threads are safe if they have no java stack or have walkable stack
609 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();
610
611 // blocked threads should have already have walkable stack
612 case _thread_blocked:
613 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");
614 return true;
615
616 default:
617 return false;
618 }
619 }
620
621
622 // See if the thread is running inside a lazy critical native and
623 // update the thread critical count if so. Also set a suspend flag to
|
55 #include "runtime/synchronizer.hpp"
56 #include "runtime/thread.inline.hpp"
57 #include "runtime/timerTrace.hpp"
58 #include "services/runtimeService.hpp"
59 #include "trace/tracing.hpp"
60 #include "trace/traceMacros.hpp"
61 #include "utilities/events.hpp"
62 #include "utilities/macros.hpp"
63 #if INCLUDE_ALL_GCS
64 #include "gc/shenandoah/shenandoahConcurrentThread.hpp"
65 #include "gc/cms/concurrentMarkSweepThread.hpp"
66 #include "gc/g1/suspendibleThreadSet.hpp"
67 #endif // INCLUDE_ALL_GCS
68 #ifdef COMPILER1
69 #include "c1/c1_globals.hpp"
70 #endif
71
72 // --------------------------------------------------------------------------------------------------
73 // Implementation of Safepoint begin/end
74
75 WorkGang* SafepointSynchronize::_cleanup_workers = NULL;
76 SubTasksDone* SafepointSynchronize::_cleanup_subtasks = NULL;
77
78 SafepointSynchronize::SynchronizeState volatile SafepointSynchronize::_state = SafepointSynchronize::_not_synchronized;
79 volatile int SafepointSynchronize::_waiting_to_block = 0;
80 volatile int SafepointSynchronize::_safepoint_counter = 0;
81 int SafepointSynchronize::_current_jni_active_count = 0;
82 long SafepointSynchronize::_end_of_last_safepoint = 0;
83 static volatile int PageArmed = 0 ; // safepoint polling page is RO|RW vs PROT_NONE
84 static volatile int TryingToBlock = 0 ; // proximate value -- for advisory use only
85 static bool timeout_error_printed = false;
86
87 // Roll all threads forward to a safepoint and suspend them all
88 void SafepointSynchronize::begin() {
89 EventSafepointBegin begin_event;
90 Thread* myThread = Thread::current();
91 assert(myThread->is_VM_thread(), "Only VM thread may execute a safepoint");
92
93 if (PrintSafepointStatistics || PrintSafepointStatisticsTimeout > 0) {
94 _safepoint_begin_time = os::javaTimeNanos();
95 _ts_of_current_safepoint = tty->time_stamp().seconds();
96 }
97
529 event.commit();
530 }
531 }
532
533 bool SafepointSynchronize::is_cleanup_needed() {
534 // Need a safepoint if some inline cache buffers is non-empty
535 if (!InlineCacheBuffer::is_empty()) return true;
536 return false;
537 }
538
539 static void event_safepoint_cleanup_task_commit(EventSafepointCleanupTask& event, const char* name) {
540 if (event.should_commit()) {
541 event.set_safepointId(SafepointSynchronize::safepoint_counter());
542 event.set_name(name);
543 event.commit();
544 }
545 }
546
547 // Various cleaning tasks that should be done periodically at safepoints
548 void SafepointSynchronize::do_cleanup_tasks() {
549 VM_Operation* op = VMThread::vm_operation();
550 // If op does both deflating and nmethod marking, we don't bother firing up
551 // the workers.
552 bool op_does_cleanup = op != NULL && op->marks_nmethods() && op->deflates_idle_monitors();
553 if (ParallelSafepointCleanup && ! op_does_cleanup) {
554 parallel_cleanup();
555 } else {
556 serial_cleanup();
557 }
558 }
559
560 void SafepointSynchronize::serial_cleanup() {
561 VM_Operation* op = VMThread::vm_operation();
562 {
563 const char* name = "deflating idle monitors";
564 EventSafepointCleanupTask event;
565 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
566 ObjectSynchronizer::deflate_idle_monitors(op == NULL || ! op->deflates_idle_monitors());
567 event_safepoint_cleanup_task_commit(event, name);
568 }
569
570 {
571 const char* name = "updating inline caches";
572 EventSafepointCleanupTask event;
573 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
574 InlineCacheBuffer::update_inline_caches();
575 event_safepoint_cleanup_task_commit(event, name);
576 }
577 {
578 const char* name = "compilation policy safepoint handler";
579 EventSafepointCleanupTask event;
580 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));
581 CompilationPolicy::policy()->do_safepoint_work();
582 event_safepoint_cleanup_task_commit(event, name);
583 }
584
585 if (op == NULL || ! op->marks_nmethods()) {
586 const char* name = "mark nmethods";
587 EventSafepointCleanupTask event;
588 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
589 NMethodSweeper::mark_active_nmethods();
590 event_safepoint_cleanup_task_commit(event, name);
591 }
592
593 if (SymbolTable::needs_rehashing()) {
594 double start = os::elapsedTime();
595 const char* name = "rehashing symbol table";
596 EventSafepointCleanupTask event;
597 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
598 SymbolTable::rehash_table();
599 event_safepoint_cleanup_task_commit(event, name);
600 double end = os::elapsedTime();
601 tty->print_cr("vmthread took: %f ms for symbol table rehash", (end - start) * 1000.0);
602 }
603
604 if (StringTable::needs_rehashing()) {
605 const char* name = "rehashing string table";
606 EventSafepointCleanupTask event;
607 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
608 StringTable::rehash_table();
609 event_safepoint_cleanup_task_commit(event, name);
610 }
611
612 {
613 // CMS delays purging the CLDG until the beginning of the next safepoint and to
614 // make sure concurrent sweep is done
615 const char* name = "purging class loader data graph";
616 EventSafepointCleanupTask event;
617 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
618 ClassLoaderDataGraph::purge_if_needed();
619 event_safepoint_cleanup_task_commit(event, name);
620 }
621 }
622
623 class ParallelSPCleanupThreadClosure : public ThreadClosure {
624 private:
625 bool _do_deflate_idle_monitors;
626 CodeBlobClosure* _nmethod_cl;
627
628 public:
629 ParallelSPCleanupThreadClosure() {
630 VM_Operation* op = VMThread::vm_operation();
631 _do_deflate_idle_monitors = op == NULL || ! op->deflates_idle_monitors();
632 if (op == NULL || ! op->marks_nmethods()) {
633 _nmethod_cl = NMethodSweeper::prepare_mark_active_nmethods();
634 } else {
635 _nmethod_cl = NULL;
636 }
637 }
638
639 void do_thread(Thread* thread) {
640 if (_do_deflate_idle_monitors) {
641 ObjectSynchronizer::deflate_idle_monitors_and_oops_do(thread, NULL);
642 }
643 if (_nmethod_cl != NULL && thread->is_Java_thread() &&
644 ! thread->is_Code_cache_sweeper_thread()) {
645 JavaThread* jt = (JavaThread*) thread;
646 jt->nmethods_do(_nmethod_cl);
647 }
648 }
649 };
650
651 class ParallelSPCleanupTask : public AbstractGangTask {
652 private:
653 SubTasksDone* _subtasks;
654 ParallelSPCleanupThreadClosure _cleanup_threads_cl;
655 public:
656 ParallelSPCleanupTask(SubTasksDone* subtasks) :
657 AbstractGangTask("Parallel Safepoint Cleanup"),
658 _cleanup_threads_cl(ParallelSPCleanupThreadClosure()),
659 _subtasks(subtasks) {}
660
661 void work(uint worker_id) {
662 // All threads deflate monitors and mark nmethods (if necessary).
663 Threads::parallel_java_threads_do(&_cleanup_threads_cl);
664
665 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
666 const char* name = "deflating idle monitors";
667 EventSafepointCleanupTask event;
668 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
669 ObjectSynchronizer::deflate_idle_monitors(false);
670 event_safepoint_cleanup_task_commit(event, name);
671 }
672
673 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
674 const char* name = "updating inline caches";
675 EventSafepointCleanupTask event;
676 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
677 InlineCacheBuffer::update_inline_caches();
678 event_safepoint_cleanup_task_commit(event, name);
679 }
680
681 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
682 const char* name = "compilation policy safepoint handler";
683 EventSafepointCleanupTask event;
684 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));
685 CompilationPolicy::policy()->do_safepoint_work();
686 event_safepoint_cleanup_task_commit(event, name);
687 }
688
689 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH)) {
690 if (SymbolTable::needs_rehashing()) {
691 const char* name = "rehashing symbol table";
692 EventSafepointCleanupTask event;
693 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
694 SymbolTable::rehash_table();
695 event_safepoint_cleanup_task_commit(event, name);
696 }
697 }
698
699 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_STRING_TABLE_REHASH)) {
700 if (StringTable::needs_rehashing()) {
701 const char* name = "rehashing string table";
702 EventSafepointCleanupTask event;
703 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
704 StringTable::rehash_table();
705 event_safepoint_cleanup_task_commit(event, name);
706 }
707 }
708
709 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_CLD_PURGE)) {
710 // CMS delays purging the CLDG until the beginning of the next safepoint and to
711 // make sure concurrent sweep is done
712 const char* name = "purging class loader data graph";
713 EventSafepointCleanupTask event;
714 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
715 ClassLoaderDataGraph::purge_if_needed();
716 event_safepoint_cleanup_task_commit(event, name);
717 }
718 _subtasks->all_tasks_completed(ParallelSafepointCleanupThreads);
719 }
720 };
721
722 void SafepointSynchronize::parallel_cleanup() {
723 // Deferred init
724 if (_cleanup_workers == NULL) {
725 _cleanup_workers = new WorkGang("Parallel Safepoint Cleanup", ParallelSafepointCleanupThreads, false, false);
726 _cleanup_workers->initialize_workers();
727 _cleanup_subtasks = new SubTasksDone(SAFEPOINT_CLEANUP_NUM_TASKS);
728 }
729
730 StrongRootsScope srs(_cleanup_workers->active_workers());
731 ParallelSPCleanupTask cleanup_task(_cleanup_subtasks);
732 _cleanup_workers->run_task(&cleanup_task);
733 }
734
735 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {
736 switch(state) {
737 case _thread_in_native:
738 // native threads are safe if they have no java stack or have walkable stack
739 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();
740
741 // blocked threads should have already have walkable stack
742 case _thread_blocked:
743 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");
744 return true;
745
746 default:
747 return false;
748 }
749 }
750
751
752 // See if the thread is running inside a lazy critical native and
753 // update the thread critical count if so. Also set a suspend flag to
|