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 const char* name = "rehashing symbol table";
595 EventSafepointCleanupTask event;
596 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
597 SymbolTable::rehash_table();
598 event_safepoint_cleanup_task_commit(event, name);
599 }
600
601 if (StringTable::needs_rehashing()) {
602 const char* name = "rehashing string table";
603 EventSafepointCleanupTask event;
604 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
605 StringTable::rehash_table();
606 event_safepoint_cleanup_task_commit(event, name);
607 }
608
609 {
610 // CMS delays purging the CLDG until the beginning of the next safepoint and to
611 // make sure concurrent sweep is done
612 const char* name = "purging class loader data graph";
613 EventSafepointCleanupTask event;
614 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
615 ClassLoaderDataGraph::purge_if_needed();
616 event_safepoint_cleanup_task_commit(event, name);
617 }
618 }
619
620 class ParallelSPCleanupThreadClosure : public ThreadClosure {
621 private:
622 bool _do_deflate_idle_monitors;
623 CodeBlobClosure* _nmethod_cl;
624
625 public:
626 ParallelSPCleanupThreadClosure() {
627 VM_Operation* op = VMThread::vm_operation();
628 _do_deflate_idle_monitors = op == NULL || ! op->deflates_idle_monitors();
629 if (op == NULL || ! op->marks_nmethods()) {
630 _nmethod_cl = NMethodSweeper::prepare_mark_active_nmethods();
631 } else {
632 _nmethod_cl = NULL;
633 }
634 }
635
636 void do_thread(Thread* thread) {
637 if (_do_deflate_idle_monitors) {
638 ObjectSynchronizer::deflate_idle_monitors_and_oops_do(thread, NULL);
639 }
640 if (_nmethod_cl != NULL && thread->is_Java_thread() &&
641 ! thread->is_Code_cache_sweeper_thread()) {
642 JavaThread* jt = (JavaThread*) thread;
643 jt->nmethods_do(_nmethod_cl);
644 }
645 }
646 };
647
648 class ParallelSPCleanupTask : public AbstractGangTask {
649 private:
650 SubTasksDone* _subtasks;
651 ParallelSPCleanupThreadClosure _cleanup_threads_cl;
652 public:
653 ParallelSPCleanupTask(SubTasksDone* subtasks) :
654 AbstractGangTask("Parallel Safepoint Cleanup"),
655 _cleanup_threads_cl(ParallelSPCleanupThreadClosure()),
656 _subtasks(subtasks) {}
657
658 void work(uint worker_id) {
659 // All threads deflate monitors and mark nmethods (if necessary).
660 Threads::parallel_java_threads_do(&_cleanup_threads_cl);
661
662 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
663 const char* name = "deflating idle monitors";
664 EventSafepointCleanupTask event;
665 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
666 ObjectSynchronizer::deflate_idle_monitors(false);
667 event_safepoint_cleanup_task_commit(event, name);
668 }
669
670 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
671 const char* name = "updating inline caches";
672 EventSafepointCleanupTask event;
673 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
674 InlineCacheBuffer::update_inline_caches();
675 event_safepoint_cleanup_task_commit(event, name);
676 }
677
678 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
679 const char* name = "compilation policy safepoint handler";
680 EventSafepointCleanupTask event;
681 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));
682 CompilationPolicy::policy()->do_safepoint_work();
683 event_safepoint_cleanup_task_commit(event, name);
684 }
685
686 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH)) {
687 if (SymbolTable::needs_rehashing()) {
688 const char* name = "rehashing symbol table";
689 EventSafepointCleanupTask event;
690 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
691 SymbolTable::rehash_table();
692 event_safepoint_cleanup_task_commit(event, name);
693 }
694 }
695
696 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_STRING_TABLE_REHASH)) {
697 if (StringTable::needs_rehashing()) {
698 const char* name = "rehashing string table";
699 EventSafepointCleanupTask event;
700 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
701 StringTable::rehash_table();
702 event_safepoint_cleanup_task_commit(event, name);
703 }
704 }
705
706 if (! _subtasks->is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_CLD_PURGE)) {
707 // CMS delays purging the CLDG until the beginning of the next safepoint and to
708 // make sure concurrent sweep is done
709 const char* name = "purging class loader data graph";
710 EventSafepointCleanupTask event;
711 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
712 ClassLoaderDataGraph::purge_if_needed();
713 event_safepoint_cleanup_task_commit(event, name);
714 }
715 _subtasks->all_tasks_completed(ParallelSafepointCleanupThreads);
716 }
717 };
718
719 void SafepointSynchronize::parallel_cleanup() {
720 // Deferred init
721 if (_cleanup_workers == NULL) {
722 _cleanup_workers = new WorkGang("Parallel Safepoint Cleanup", ParallelSafepointCleanupThreads, false, false);
723 _cleanup_workers->initialize_workers();
724 _cleanup_subtasks = new SubTasksDone(SAFEPOINT_CLEANUP_NUM_TASKS);
725 }
726
727 StrongRootsScope srs(_cleanup_workers->active_workers());
728 ParallelSPCleanupTask cleanup_task(_cleanup_subtasks);
729 _cleanup_workers->run_task(&cleanup_task);
730 }
731
732 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {
733 switch(state) {
734 case _thread_in_native:
735 // native threads are safe if they have no java stack or have walkable stack
736 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();
737
738 // blocked threads should have already have walkable stack
739 case _thread_blocked:
740 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");
741 return true;
742
743 default:
744 return false;
745 }
746 }
747
748
749 // See if the thread is running inside a lazy critical native and
750 // 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 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
|