8291718: Remove mark_for_deoptimization from klass unloading

Reviewed-by: eosterlund, dlong

Author: xmas92

src/hotspot/share/code/codeCache.cpp

@@ -758,9 +758,8 @@ int CodeCache::alignment_offset() {
 }
 
 // Mark nmethods for unloading if they contain otherwise unreachable oops.
-void CodeCache::do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred) {
+void CodeCache::do_unloading(bool unloading_occurred) {
   assert_locked_or_safepoint(CodeCache_lock);
-  UnloadingScope scope(is_alive);
   CompiledMethodIterator iter(CompiledMethodIterator::only_alive);
   while(iter.next()) {
     iter.method()->do_unloading(unloading_occurred);

src/hotspot/share/code/codeCache.hpp

@@ -197,7 +197,7 @@ class CodeCache : AllStatic {
     ~UnloadingScope();
   };
 
-  static void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);
+  static void do_unloading(bool unloading_occurred);
   static uint8_t unloading_cycle() { return _unloading_cycle; }
 
   static void increment_unloading_cycle();

src/hotspot/share/code/dependencyContext.cpp

@@ -205,26 +205,31 @@ void DependencyContext::clean_unloading_dependents() {
   }
 }
 
+nmethodBucket* DependencyContext::release_and_get_next_not_unloading(nmethodBucket* b) {
+  nmethodBucket* next = b->next_not_unloading();
+  release(b);
+  return next;
+ }
+
 //
 // Invalidate all dependencies in the context
-int DependencyContext::remove_all_dependents() {
+void DependencyContext::remove_all_dependents() {
+  nmethodBucket* b = dependencies_not_unloading();
+  set_dependencies(NULL);
+  assert(b == nullptr, "All dependents should be unloading");
+}
+
+int DependencyContext::remove_and_mark_for_deoptimization_all_dependents() {
   nmethodBucket* b = dependencies_not_unloading();
   set_dependencies(NULL);
   int marked = 0;
-  int removed = 0;
   while (b != NULL) {
     nmethod* nm = b->get_nmethod();
     if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization()) {
       nm->mark_for_deoptimization();
       marked++;
     }
-    nmethodBucket* next = b->next_not_unloading();
-    removed++;
-    release(b);
-    b = next;
-  }
-  if (UsePerfData && removed > 0) {
-    _perf_total_buckets_deallocated_count->inc(removed);
+    b = release_and_get_next_not_unloading(b);
   }
   return marked;
 }

src/hotspot/share/code/dependencyContext.hpp

@@ -120,8 +120,10 @@ class DependencyContext : public StackObj {
   int  mark_dependent_nmethods(DepChange& changes);
   void add_dependent_nmethod(nmethod* nm);
   void remove_dependent_nmethod(nmethod* nm);
-  int  remove_all_dependents();
+  void remove_all_dependents();
+  int  remove_and_mark_for_deoptimization_all_dependents();
   void clean_unloading_dependents();
+  static nmethodBucket* release_and_get_next_not_unloading(nmethodBucket* b);
   static void purge_dependency_contexts();
   static void release(nmethodBucket* b);
   static void cleaning_start();

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -2882,10 +2882,9 @@ void G1CollectedHeap::do_collection_pause_at_safepoint_helper(double target_paus
   }
 }
 
-void G1CollectedHeap::complete_cleaning(BoolObjectClosure* is_alive,
-                                        bool class_unloading_occurred) {
+void G1CollectedHeap::complete_cleaning(bool class_unloading_occurred) {
   uint num_workers = workers()->active_workers();
-  G1ParallelCleaningTask unlink_task(is_alive, num_workers, class_unloading_occurred);
+  G1ParallelCleaningTask unlink_task(num_workers, class_unloading_occurred);
   workers()->run_task(&unlink_task);
 }
 

src/hotspot/share/gc/g1/g1CollectedHeap.hpp

@@ -1261,7 +1261,7 @@ class G1CollectedHeap : public CollectedHeap {
   void rebuild_code_roots();
 
   // Performs cleaning of data structures after class unloading.
-  void complete_cleaning(BoolObjectClosure* is_alive, bool class_unloading_occurred);
+  void complete_cleaning(bool class_unloading_occurred);
 
   // Verification
 

src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -1689,8 +1689,9 @@ void G1ConcurrentMark::weak_refs_work() {
   // Unload Klasses, String, Code Cache, etc.
   if (ClassUnloadingWithConcurrentMark) {
     GCTraceTime(Debug, gc, phases) debug("Class Unloading", _gc_timer_cm);
+    CodeCache::UnloadingScope scope(&g1_is_alive);
     bool purged_classes = SystemDictionary::do_unloading(_gc_timer_cm);
-    _g1h->complete_cleaning(&g1_is_alive, purged_classes);
+    _g1h->complete_cleaning(purged_classes);
   }
 }
 

src/hotspot/share/gc/g1/g1FullCollector.cpp

@@ -301,9 +301,10 @@ void G1FullCollector::phase1_mark_live_objects() {
   // Class unloading and cleanup.
   if (ClassUnloading) {
     GCTraceTime(Debug, gc, phases) debug("Phase 1: Class Unloading and Cleanup", scope()->timer());
+    CodeCache::UnloadingScope unloading_scope(&_is_alive);
     // Unload classes and purge the SystemDictionary.
     bool purged_class = SystemDictionary::do_unloading(scope()->timer());
-    _heap->complete_cleaning(&_is_alive, purged_class);
+    _heap->complete_cleaning(purged_class);
   }
 
   scope()->tracer()->report_object_count_after_gc(&_is_alive);

src/hotspot/share/gc/g1/g1ParallelCleaning.cpp

@@ -51,12 +51,11 @@ void JVMCICleaningTask::work(bool unloading_occurred) {
 }
 #endif // INCLUDE_JVMCI
 
-G1ParallelCleaningTask::G1ParallelCleaningTask(BoolObjectClosure* is_alive,
-                                               uint num_workers,
+G1ParallelCleaningTask::G1ParallelCleaningTask(uint num_workers,
                                                bool unloading_occurred) :
   WorkerTask("G1 Parallel Cleaning"),
   _unloading_occurred(unloading_occurred),
-  _code_cache_task(num_workers, is_alive, unloading_occurred),
+  _code_cache_task(num_workers, unloading_occurred),
   JVMCI_ONLY(_jvmci_cleaning_task() COMMA)
   _klass_cleaning_task() {
 }

src/hotspot/share/gc/g1/g1ParallelCleaning.hpp

@@ -54,8 +54,7 @@ class G1ParallelCleaningTask : public WorkerTask {
 
 public:
   // The constructor is run in the VMThread.
-  G1ParallelCleaningTask(BoolObjectClosure* is_alive,
-                         uint num_workers,
+  G1ParallelCleaningTask(uint num_workers,
                          bool unloading_occurred);
 
   void work(uint worker_id);