473 _wait_barrier->disarm();
474 }
475
476 // Wake up all threads, so they are ready to resume execution after the safepoint
477 // operation has been carried out
478 void SafepointSynchronize::end() {
479 assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
480 EventSafepointEnd event;
481 assert(Thread::current()->is_VM_thread(), "Only VM thread can execute a safepoint");
482
483 disarm_safepoint();
484
485 Universe::heap()->safepoint_synchronize_end();
486
487 SafepointTracing::end();
488
489 post_safepoint_end_event(event, safepoint_id());
490 }
491
492 bool SafepointSynchronize::is_cleanup_needed() {
493 // Need a safepoint if there are many monitors to deflate.
494 if (ObjectSynchronizer::is_cleanup_needed()) return true;
495 // Need a safepoint if some inline cache buffers is non-empty
496 if (!InlineCacheBuffer::is_empty()) return true;
497 if (StringTable::needs_rehashing()) return true;
498 if (SymbolTable::needs_rehashing()) return true;
499 return false;
500 }
501
502 class ParallelSPCleanupThreadClosure : public ThreadClosure {
503 private:
504 CodeBlobClosure* _nmethod_cl;
505 DeflateMonitorCounters* _counters;
506
507 public:
508 ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
509 _nmethod_cl(UseCodeAging ? NMethodSweeper::prepare_reset_hotness_counters() : NULL),
510 _counters(counters) {}
511
512 void do_thread(Thread* thread) {
513 ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
514 if (_nmethod_cl != NULL && thread->is_Java_thread() &&
515 ! thread->is_Code_cache_sweeper_thread()) {
516 JavaThread* jt = (JavaThread*) thread;
517 jt->nmethods_do(_nmethod_cl);
518 }
519 }
520 };
521
522 class ParallelSPCleanupTask : public AbstractGangTask {
523 private:
524 SubTasksDone _subtasks;
525 ParallelSPCleanupThreadClosure _cleanup_threads_cl;
526 uint _num_workers;
527 DeflateMonitorCounters* _counters;
528 public:
529 ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
530 AbstractGangTask("Parallel Safepoint Cleanup"),
531 _subtasks(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS),
532 _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
533 _num_workers(num_workers),
534 _counters(counters) {}
535
536 void work(uint worker_id) {
537 uint64_t safepoint_id = SafepointSynchronize::safepoint_id();
538 // All threads deflate monitors and mark nmethods (if necessary).
539 Threads::possibly_parallel_threads_do(true, &_cleanup_threads_cl);
540
541 if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
542 const char* name = "deflating global idle monitors";
543 EventSafepointCleanupTask event;
544 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
545 ObjectSynchronizer::deflate_idle_monitors(_counters);
546
547 post_safepoint_cleanup_task_event(event, safepoint_id, name);
548 }
549
550 if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
551 const char* name = "updating inline caches";
552 EventSafepointCleanupTask event;
553 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
554 InlineCacheBuffer::update_inline_caches();
555
556 post_safepoint_cleanup_task_event(event, safepoint_id, name);
557 }
558
559 if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
560 const char* name = "compilation policy safepoint handler";
561 EventSafepointCleanupTask event;
562 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
563 CompilationPolicy::policy()->do_safepoint_work();
564
565 post_safepoint_cleanup_task_event(event, safepoint_id, name);
|
473 _wait_barrier->disarm();
474 }
475
476 // Wake up all threads, so they are ready to resume execution after the safepoint
477 // operation has been carried out
478 void SafepointSynchronize::end() {
479 assert(Threads_lock->owned_by_self(), "must hold Threads_lock");
480 EventSafepointEnd event;
481 assert(Thread::current()->is_VM_thread(), "Only VM thread can execute a safepoint");
482
483 disarm_safepoint();
484
485 Universe::heap()->safepoint_synchronize_end();
486
487 SafepointTracing::end();
488
489 post_safepoint_end_event(event, safepoint_id());
490 }
491
492 bool SafepointSynchronize::is_cleanup_needed() {
493 // Need a cleanup safepoint if there are too many monitors in use
494 // and the monitor deflation needs to be done at a safepoint.
495 if (ObjectSynchronizer::is_safepoint_deflation_needed()) return true;
496 // Need a safepoint if some inline cache buffers is non-empty
497 if (!InlineCacheBuffer::is_empty()) return true;
498 if (StringTable::needs_rehashing()) return true;
499 if (SymbolTable::needs_rehashing()) return true;
500 return false;
501 }
502
503 class ParallelSPCleanupThreadClosure : public ThreadClosure {
504 private:
505 CodeBlobClosure* _nmethod_cl;
506 DeflateMonitorCounters* _counters;
507
508 public:
509 ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :
510 _nmethod_cl(UseCodeAging ? NMethodSweeper::prepare_reset_hotness_counters() : NULL),
511 _counters(counters) {}
512
513 void do_thread(Thread* thread) {
514 // deflate_thread_local_monitors() handles or requests deflation of
515 // this thread's idle monitors. If !AsyncDeflateIdleMonitors or if
516 // there is a special cleanup request, deflation is handled now.
517 // Otherwise, async deflation is requested via a flag.
518 ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);
519 if (_nmethod_cl != NULL && thread->is_Java_thread() &&
520 ! thread->is_Code_cache_sweeper_thread()) {
521 JavaThread* jt = (JavaThread*) thread;
522 jt->nmethods_do(_nmethod_cl);
523 }
524 }
525 };
526
527 class ParallelSPCleanupTask : public AbstractGangTask {
528 private:
529 SubTasksDone _subtasks;
530 ParallelSPCleanupThreadClosure _cleanup_threads_cl;
531 uint _num_workers;
532 DeflateMonitorCounters* _counters;
533 public:
534 ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :
535 AbstractGangTask("Parallel Safepoint Cleanup"),
536 _subtasks(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS),
537 _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),
538 _num_workers(num_workers),
539 _counters(counters) {}
540
541 void work(uint worker_id) {
542 uint64_t safepoint_id = SafepointSynchronize::safepoint_id();
543 // All threads deflate monitors and mark nmethods (if necessary).
544 Threads::possibly_parallel_threads_do(true, &_cleanup_threads_cl);
545
546 if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {
547 const char* name = "deflating global idle monitors";
548 EventSafepointCleanupTask event;
549 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
550 // AsyncDeflateIdleMonitors only uses DeflateMonitorCounters
551 // when a special cleanup has been requested.
552 // Note: This logging output will include global idle monitor
553 // elapsed times, but not global idle monitor deflation count.
554 ObjectSynchronizer::do_safepoint_work(_counters);
555
556 post_safepoint_cleanup_task_event(event, safepoint_id, name);
557 }
558
559 if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {
560 const char* name = "updating inline caches";
561 EventSafepointCleanupTask event;
562 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
563 InlineCacheBuffer::update_inline_caches();
564
565 post_safepoint_cleanup_task_event(event, safepoint_id, name);
566 }
567
568 if (_subtasks.try_claim_task(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {
569 const char* name = "compilation policy safepoint handler";
570 EventSafepointCleanupTask event;
571 TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));
572 CompilationPolicy::policy()->do_safepoint_work();
573
574 post_safepoint_cleanup_task_event(event, safepoint_id, name);
|