523 event.commit();
524 }
525 }
526
527 bool SafepointSynchronize::is_cleanup_needed() {
528 // Need a safepoint if there are many monitors to deflate.
529 if (ObjectSynchronizer::is_cleanup_needed()) return true;
530 // Need a safepoint if some inline cache buffers is non-empty
531 if (!InlineCacheBuffer::is_empty()) return true;
532 return false;
533 }
534
535 static void event_safepoint_cleanup_task_commit(EventSafepointCleanupTask& event, const char* name) {
536 if (event.should_commit()) {
537 event.set_safepointId(SafepointSynchronize::safepoint_counter());
538 event.set_name(name);
539 event.commit();
540 }
541 }
542
543 // Various cleaning tasks that should be done periodically at safepoints
544 void SafepointSynchronize::do_cleanup_tasks() {
545 {
546 const char* name = "deflating idle monitors";
547 EventSafepointCleanupTask event;
548 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
549 ObjectSynchronizer::deflate_idle_monitors();
550 event_safepoint_cleanup_task_commit(event, name);
551 }
552
553 {
554 const char* name = "updating inline caches";
555 EventSafepointCleanupTask event;
556 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
557 InlineCacheBuffer::update_inline_caches();
558 event_safepoint_cleanup_task_commit(event, name);
559 }
560 {
561 const char* name = "compilation policy safepoint handler";
562 EventSafepointCleanupTask event;
563 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));
564 CompilationPolicy::policy()->do_safepoint_work();
565 event_safepoint_cleanup_task_commit(event, name);
566 }
567
568 {
569 const char* name = "mark nmethods";
570 EventSafepointCleanupTask event;
571 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
572 NMethodSweeper::mark_active_nmethods();
573 event_safepoint_cleanup_task_commit(event, name);
574 }
575
576 if (SymbolTable::needs_rehashing()) {
577 const char* name = "rehashing symbol table";
578 EventSafepointCleanupTask event;
579 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
580 SymbolTable::rehash_table();
581 event_safepoint_cleanup_task_commit(event, name);
582 }
583
584 if (StringTable::needs_rehashing()) {
585 const char* name = "rehashing string table";
586 EventSafepointCleanupTask event;
587 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
588 StringTable::rehash_table();
589 event_safepoint_cleanup_task_commit(event, name);
590 }
591
592 {
593 // CMS delays purging the CLDG until the beginning of the next safepoint and to
594 // make sure concurrent sweep is done
595 const char* name = "purging class loader data graph";
596 EventSafepointCleanupTask event;
597 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
598 ClassLoaderDataGraph::purge_if_needed();
599 event_safepoint_cleanup_task_commit(event, name);
600 }
601 }
602
603
604 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {
605 switch(state) {
606 case _thread_in_native:
607 // native threads are safe if they have no java stack or have walkable stack
608 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();
609
610 // blocked threads should have already have walkable stack
611 case _thread_blocked:
612 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");
613 return true;
614
615 default:
616 return false;
617 }
618 }
619
620
|
523 event.commit();
524 }
525 }
526
527 bool SafepointSynchronize::is_cleanup_needed() {
528 // Need a safepoint if there are many monitors to deflate.
529 if (ObjectSynchronizer::is_cleanup_needed()) return true;
530 // Need a safepoint if some inline cache buffers is non-empty
531 if (!InlineCacheBuffer::is_empty()) return true;
532 return false;
533 }
534
535 static void event_safepoint_cleanup_task_commit(EventSafepointCleanupTask& event, const char* name) {
536 if (event.should_commit()) {
537 event.set_safepointId(SafepointSynchronize::safepoint_counter());
538 event.set_name(name);
539 event.commit();
540 }
541 }
542
543 class ParallelSPCleanupThreadClosure : public ThreadClosure {
544 private:
545 CodeBlobClosure* _nmethod_cl;
546 DeflateMonitorCounters* _counters;
547
548 public:
549 ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
550 _counters(counters),
551 _nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()) {}
552
553 void do_thread(Thread* thread) {
554 ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
555 if (_nmethod_cl != NULL && thread->is_Java_thread() &&
556 ! thread->is_Code_cache_sweeper_thread()) {
557 JavaThread* jt = (JavaThread*) thread;
558 jt->nmethods_do(_nmethod_cl);
559 }
560 }
561 };
562
563 class ParallelSPCleanupTask : public AbstractGangTask {
564 private:
565 SubTasksDone _subtasks;
566 ParallelSPCleanupThreadClosure _cleanup_threads_cl;
567 uint _num_workers;
568 DeflateMonitorCounters* _counters;
569 public:
570 ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
571 AbstractGangTask("Parallel Safepoint Cleanup"),
572 _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
573 _num_workers(num_workers),
574 _subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),
575 _counters(counters) {}
576
577 void work(uint worker_id) {
578 // All threads deflate monitors and mark nmethods (if necessary).
579 Threads::parallel_java_threads_do(&_cleanup_threads_cl);
580
581 if (! _subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
582 const char* name = "deflating idle monitors";
583 EventSafepointCleanupTask event;
584 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
585 ObjectSynchronizer::deflate_idle_monitors(_counters);
586 event_safepoint_cleanup_task_commit(event, name);
587 }
588
589 if (! _subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
590 const char* name = "updating inline caches";
591 EventSafepointCleanupTask event;
592 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
593 InlineCacheBuffer::update_inline_caches();
594 event_safepoint_cleanup_task_commit(event, name);
595 }
596
597 if (! _subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
598 const char* name = "compilation policy safepoint handler";
599 EventSafepointCleanupTask event;
600 TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));
601 CompilationPolicy::policy()->do_safepoint_work();
602 event_safepoint_cleanup_task_commit(event, name);
603 }
604
605 if (! _subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH)) {
606 if (SymbolTable::needs_rehashing()) {
607 const char* name = "rehashing symbol table";
608 EventSafepointCleanupTask event;
609 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
610 SymbolTable::rehash_table();
611 event_safepoint_cleanup_task_commit(event, name);
612 }
613 }
614
615 if (! _subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_STRING_TABLE_REHASH)) {
616 if (StringTable::needs_rehashing()) {
617 const char* name = "rehashing string table";
618 EventSafepointCleanupTask event;
619 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
620 StringTable::rehash_table();
621 event_safepoint_cleanup_task_commit(event, name);
622 }
623 }
624
625 if (! _subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_CLD_PURGE)) {
626 // CMS delays purging the CLDG until the beginning of the next safepoint and to
627 // make sure concurrent sweep is done
628 const char* name = "purging class loader data graph";
629 EventSafepointCleanupTask event;
630 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
631 ClassLoaderDataGraph::purge_if_needed();
632 event_safepoint_cleanup_task_commit(event, name);
633 }
634 _subtasks.all_tasks_completed(_num_workers);
635 }
636 };
637
638 // Various cleaning tasks that should be done periodically at safepoints
639 void SafepointSynchronize::do_cleanup_tasks() {
640
641 // Prepare for monitor deflation
642 DeflateMonitorCounters deflate_counters;
643 ObjectSynchronizer::prepare_deflate_idle_monitors(&deflate_counters);
644
645 CollectedHeap* heap = Universe::heap();
646 assert(heap != NULL, "heap not initialized yet?");
647 WorkGang* cleanup_workers = heap->get_safepoint_workers();
648 if (cleanup_workers != NULL) {
649 // Parallel cleanup using GC provided thread pool.
650 uint num_cleanup_workers = cleanup_workers->active_workers();
651 ParallelSPCleanupTask cleanup(num_cleanup_workers, &deflate_counters);
652 StrongRootsScope srs(num_cleanup_workers);
653 cleanup_workers->run_task(&cleanup);
654 } else {
655 // Serial cleanup using VMThread.
656 ParallelSPCleanupTask cleanup(1, &deflate_counters);
657 StrongRootsScope srs(1);
658 cleanup.work(0);
659 }
660
661 // Finish monitor deflation.
662 ObjectSynchronizer::finish_deflate_idle_monitors(&deflate_counters);
663 }
664
665
666 bool SafepointSynchronize::safepoint_safe(JavaThread *thread, JavaThreadState state) {
667 switch(state) {
668 case _thread_in_native:
669 // native threads are safe if they have no java stack or have walkable stack
670 return !thread->has_last_Java_frame() || thread->frame_anchor()->walkable();
671
672 // blocked threads should have already have walkable stack
673 case _thread_blocked:
674 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "blocked and not walkable");
675 return true;
676
677 default:
678 return false;
679 }
680 }
681
682
|