546 // Various cleaning tasks that should be done periodically at safepoints

   548 class ParallelSPCleanupThreadClosure : public ThreadClosure {

   549 private:

   550   CodeBlobClosure* _nmethod_cl;

   551   DeflateMonitorCounters* _counters;

   552 

   553 public:

   554   ParallelSPCleanupThreadClosure(DeflateMonitorCounters* counters) :

   555     _counters(counters),

   556     _nmethod_cl(NMethodSweeper::prepare_mark_active_nmethods()) {}

   557 

   558   void do_thread(Thread* thread) {

   559     ObjectSynchronizer::deflate_thread_local_monitors(thread, _counters);

   560     if (_nmethod_cl != NULL && thread->is_Java_thread() &&

   561         ! thread->is_Code_cache_sweeper_thread()) {

   562       JavaThread* jt = (JavaThread*) thread;

   563       jt->nmethods_do(_nmethod_cl);

   564     }

   565   }

   566 };

   567 

   568 class ParallelSPCleanupTask : public AbstractGangTask {

   569 private:

   570   SubTasksDone _subtasks;

   571   ParallelSPCleanupThreadClosure _cleanup_threads_cl;

   572   uint _num_workers;

   573   DeflateMonitorCounters* _counters;

   574 public:

   575   ParallelSPCleanupTask(uint num_workers, DeflateMonitorCounters* counters) :

   576     AbstractGangTask("Parallel Safepoint Cleanup"),

   577     _cleanup_threads_cl(ParallelSPCleanupThreadClosure(counters)),

   578     _num_workers(num_workers),

   579     _subtasks(SubTasksDone(SafepointSynchronize::SAFEPOINT_CLEANUP_NUM_TASKS)),

   580     _counters(counters) {}

   581 

   582   void work(uint worker_id) {

   583     // All threads deflate monitors and mark nmethods (if necessary).

   584     Threads::parallel_java_threads_do(&_cleanup_threads_cl);

   585 

   586     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_DEFLATE_MONITORS)) {

   587       const char* name = "deflating idle monitors";

   588       EventSafepointCleanupTask event;

   589       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   590       ObjectSynchronizer::deflate_idle_monitors(_counters);

   591       event_safepoint_cleanup_task_commit(event, name);

   592     }

   593 

   594     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES)) {

   595       const char* name = "updating inline caches";

   596       EventSafepointCleanupTask event;

   597       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   598       InlineCacheBuffer::update_inline_caches();

   599       event_safepoint_cleanup_task_commit(event, name);

   600     }

   601 

   602     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_COMPILATION_POLICY)) {

   603       const char* name = "compilation policy safepoint handler";

   604       EventSafepointCleanupTask event;

   605       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   606       CompilationPolicy::policy()->do_safepoint_work();

   607       event_safepoint_cleanup_task_commit(event, name);

   608     }

   609 

   610     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH)) {

   611       if (SymbolTable::needs_rehashing()) {

   612         const char* name = "rehashing symbol table";

   613         EventSafepointCleanupTask event;

   614         TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   615         SymbolTable::rehash_table();

   616         event_safepoint_cleanup_task_commit(event, name);

   617       }

   618     }

   619 

   620     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_STRING_TABLE_REHASH)) {

   621       if (StringTable::needs_rehashing()) {

   622         const char* name = "rehashing string table";

   623         EventSafepointCleanupTask event;

   624         TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   625         StringTable::rehash_table();

   626         event_safepoint_cleanup_task_commit(event, name);

   627       }

   628     }

   629 

   630     if (!_subtasks.is_task_claimed(SafepointSynchronize::SAFEPOINT_CLEANUP_CLD_PURGE)) {

   631       // CMS delays purging the CLDG until the beginning of the next safepoint and to

   632       // make sure concurrent sweep is done

   633       const char* name = "purging class loader data graph";

   634       EventSafepointCleanupTask event;

   635       TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   636       ClassLoaderDataGraph::purge_if_needed();

   637       event_safepoint_cleanup_task_commit(event, name);

   638     }

   639     _subtasks.all_tasks_completed(_num_workers);

   640   }

   641 };

   642 

   643 // Various cleaning tasks that should be done periodically at safepoints.

   548   {

   645 

   549     const char* name = "deflating idle monitors";

   646   TraceTime timer("safepoint cleanup tasks", TRACETIME_LOG(Info, safepoint, cleanup));

   550     EventSafepointCleanupTask event;

   647 

   551     TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   648   // Prepare for monitor deflation.

   552     ObjectSynchronizer::deflate_idle_monitors();

   649   DeflateMonitorCounters deflate_counters;

   553     event_safepoint_cleanup_task_commit(event, name);

   650   ObjectSynchronizer::prepare_deflate_idle_monitors(&deflate_counters);

   554   }

   651 

   555 

   652   CollectedHeap* heap = Universe::heap();

   556   {

   653   assert(heap != NULL, "heap not initialized yet?");

   557     const char* name = "updating inline caches";

   654   WorkGang* cleanup_workers = heap->get_safepoint_workers();

   558     EventSafepointCleanupTask event;

   655   if (cleanup_workers != NULL) {

   559     TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   656     // Parallel cleanup using GC provided thread pool.

   560     InlineCacheBuffer::update_inline_caches();

   657     uint num_cleanup_workers = cleanup_workers->active_workers();

   561     event_safepoint_cleanup_task_commit(event, name);

   658     ParallelSPCleanupTask cleanup(num_cleanup_workers, &deflate_counters);

   562   }

   659     StrongRootsScope srs(num_cleanup_workers);

   563   {

   660     cleanup_workers->run_task(&cleanup);

   564     const char* name = "compilation policy safepoint handler";

   661   } else {

   565     EventSafepointCleanupTask event;

   662     // Serial cleanup using VMThread.

   566     TraceTime timer("compilation policy safepoint handler", TRACETIME_LOG(Info, safepoint, cleanup));

   663     ParallelSPCleanupTask cleanup(1, &deflate_counters);

   567     CompilationPolicy::policy()->do_safepoint_work();

   664     StrongRootsScope srs(1);

   568     event_safepoint_cleanup_task_commit(event, name);

   665     cleanup.work(0);

   569   }

   666   }

   570 

   667 

   571   {

   668   // Finish monitor deflation.

   572     const char* name = "mark nmethods";

   669   ObjectSynchronizer::finish_deflate_idle_monitors(&deflate_counters);

   573     EventSafepointCleanupTask event;

   574     TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   575     NMethodSweeper::mark_active_nmethods();

   576     event_safepoint_cleanup_task_commit(event, name);

   577   }

   578 

   579   if (SymbolTable::needs_rehashing()) {

   580     const char* name = "rehashing symbol table";

   581     EventSafepointCleanupTask event;

   582     TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   583     SymbolTable::rehash_table();

   584     event_safepoint_cleanup_task_commit(event, name);

   585   }

   586 

   587   if (StringTable::needs_rehashing()) {

   588     const char* name = "rehashing string table";

   589     EventSafepointCleanupTask event;

   590     TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   591     StringTable::rehash_table();

   592     event_safepoint_cleanup_task_commit(event, name);

   593   }

   594 

   595   {

   596     // CMS delays purging the CLDG until the beginning of the next safepoint and to

   597     // make sure concurrent sweep is done

   598     const char* name = "purging class loader data graph";

   599     EventSafepointCleanupTask event;

   600     TraceTime timer(name, TRACETIME_LOG(Info, safepoint, cleanup));

   601     ClassLoaderDataGraph::purge_if_needed();

   602     event_safepoint_cleanup_task_commit(event, name);

   603   }