8329629: GC interfaces should work directly against nmethod instead of CodeBlob

Reviewed-by: ayang, eosterlund

Author: stefank

src/hotspot/share/code/codeCache.cpp

@@ -685,6 +685,14 @@ void CodeCache::nmethods_do(void f(nmethod* nm)) {
   }
 }
 
+void CodeCache::nmethods_do(NMethodClosure* cl) {
+  assert_locked_or_safepoint(CodeCache_lock);
+  NMethodIterator iter(NMethodIterator::all_blobs);
+  while(iter.next()) {
+    cl->do_nmethod(iter.method());
+  }
+}
+
 void CodeCache::metadata_do(MetadataClosure* f) {
   assert_locked_or_safepoint(CodeCache_lock);
   NMethodIterator iter(NMethodIterator::all_blobs);
@@ -883,20 +891,6 @@ void CodeCache::do_unloading(bool unloading_occurred) {
   }
 }
 
-void CodeCache::blobs_do(CodeBlobClosure* f) {
-  assert_locked_or_safepoint(CodeCache_lock);
-  FOR_ALL_ALLOCABLE_HEAPS(heap) {
-    FOR_ALL_BLOBS(cb, *heap) {
-      f->do_code_blob(cb);
-#ifdef ASSERT
-      if (cb->is_nmethod()) {
-        Universe::heap()->verify_nmethod((nmethod*)cb);
-      }
-#endif //ASSERT
-    }
-  }
-}
-
 void CodeCache::verify_clean_inline_caches() {
 #ifdef ASSERT
   NMethodIterator iter(NMethodIterator::only_not_unloading);

src/hotspot/share/code/codeCache.hpp

@@ -153,8 +153,8 @@ class CodeCache : AllStatic {
   static bool contains(void *p);                           // returns whether p is included
   static bool contains(nmethod* nm);                       // returns whether nm is included
   static void blobs_do(void f(CodeBlob* cb));              // iterates over all CodeBlobs
-  static void blobs_do(CodeBlobClosure* f);                // iterates over all CodeBlobs
   static void nmethods_do(void f(nmethod* nm));            // iterates over all nmethods
+  static void nmethods_do(NMethodClosure* cl);             // iterates over all nmethods
   static void metadata_do(MetadataClosure* f);             // iterates over metadata in alive nmethods
 
   // Lookup

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

@@ -152,7 +152,7 @@ class G1CodeRootSetHashTable : public CHeapObj<mtGC> {
     clean(always_true);
   }
 
-  void iterate_at_safepoint(CodeBlobClosure* blk) {
+  void iterate_at_safepoint(NMethodClosure* blk) {
     assert_at_safepoint();
     // A lot of code root sets are typically empty.
     if (is_empty()) {
@@ -161,7 +161,7 @@ class G1CodeRootSetHashTable : public CHeapObj<mtGC> {
 
     auto do_value =
       [&] (nmethod** value) {
-        blk->do_code_blob(*value);
+        blk->do_nmethod(*value);
         return true;
       };
     _table_scanner.do_safepoint_scan(do_value);
@@ -288,7 +288,7 @@ void G1CodeRootSet::reset_table_scanner() {
   _table->reset_table_scanner();
 }
 
-void G1CodeRootSet::nmethods_do(CodeBlobClosure* blk) const {
+void G1CodeRootSet::nmethods_do(NMethodClosure* blk) const {
   DEBUG_ONLY(_is_iterating = true;)
   _table->iterate_at_safepoint(blk);
   DEBUG_ONLY(_is_iterating = false;)
@@ -317,14 +317,14 @@ class CleanCallback : public StackObj {
   };
 
   PointsIntoHRDetectionClosure _detector;
-  CodeBlobToOopClosure _blobs;
+  NMethodToOopClosure _nmethod_cl;
 
  public:
-  CleanCallback(HeapRegion* hr) : _detector(hr), _blobs(&_detector, !CodeBlobToOopClosure::FixRelocations) {}
+  CleanCallback(HeapRegion* hr) : _detector(hr), _nmethod_cl(&_detector, !NMethodToOopClosure::FixRelocations) {}
 
   bool operator()(nmethod** value) {
     _detector._points_into = false;
-    _blobs.do_code_blob(*value);
+    _nmethod_cl.do_nmethod(*value);
     return !_detector._points_into;
   }
 };

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

@@ -50,7 +50,7 @@ class G1CodeRootSet {
 
   // Prepare for MT iteration. Must be called before nmethods_do.
   void reset_table_scanner();
-  void nmethods_do(CodeBlobClosure* blk) const;
+  void nmethods_do(NMethodClosure* blk) const;
 
   // Remove all nmethods which no longer contain pointers into our "owner" region.
   void clean(HeapRegion* owner);

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

@@ -2518,7 +2518,7 @@ void G1CollectedHeap::unload_classes_and_code(const char* description, BoolObjec
 
   ClassUnloadingContext ctx(workers()->active_workers(),
                             false /* unregister_nmethods_during_purge */,
-                            false /* lock_codeblob_free_separately */);
+                            false /* lock_nmethod_free_separately */);
   {
     CodeCache::UnlinkingScope scope(is_alive);
     bool unloading_occurred = SystemDictionary::do_unloading(timer);
@@ -2535,7 +2535,7 @@ void G1CollectedHeap::unload_classes_and_code(const char* description, BoolObjec
   }
   {
     GCTraceTime(Debug, gc, phases) t("Free Code Blobs", timer);
-    ctx.free_code_blobs();
+    ctx.free_nmethods();
   }
   {
     GCTraceTime(Debug, gc, phases) t("Purge Class Loader Data", timer);
@@ -3016,24 +3016,22 @@ void G1CollectedHeap::update_used_after_gc(bool evacuation_failed) {
   }
 }
 
-class RebuildCodeRootClosure: public CodeBlobClosure {
+class RebuildCodeRootClosure: public NMethodClosure {
   G1CollectedHeap* _g1h;
 
 public:
   RebuildCodeRootClosure(G1CollectedHeap* g1h) :
     _g1h(g1h) {}
 
-  void do_code_blob(CodeBlob* cb) {
-    nmethod* nm = cb->as_nmethod_or_null();
-    if (nm != nullptr) {
-      _g1h->register_nmethod(nm);
-    }
+  void do_nmethod(nmethod* nm) {
+    assert(nm != nullptr, "Sanity");
+    _g1h->register_nmethod(nm);
   }
 };
 
 void G1CollectedHeap::rebuild_code_roots() {
-  RebuildCodeRootClosure blob_cl(this);
-  CodeCache::blobs_do(&blob_cl);
+  RebuildCodeRootClosure nmethod_cl(this);
+  CodeCache::nmethods_do(&nmethod_cl);
 }
 
 void G1CollectedHeap::initialize_serviceability() {

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

@@ -101,7 +101,7 @@ void G1FullGCAdjustTask::work(uint worker_id) {
   }
 
   CLDToOopClosure adjust_cld(&_adjust, ClassLoaderData::_claim_stw_fullgc_adjust);
-  CodeBlobToOopClosure adjust_code(&_adjust, CodeBlobToOopClosure::FixRelocations);
+  NMethodToOopClosure adjust_code(&_adjust, NMethodToOopClosure::FixRelocations);
   _root_processor.process_all_roots(&_adjust, &adjust_cld, &adjust_code);
 
   // Now adjust pointers region by region

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

@@ -42,7 +42,7 @@ void G1FullGCMarkTask::work(uint worker_id) {
   Ticks start = Ticks::now();
   ResourceMark rm;
   G1FullGCMarker* marker = collector()->marker(worker_id);
-  MarkingCodeBlobClosure code_closure(marker->mark_closure(), !CodeBlobToOopClosure::FixRelocations, true /* keepalive nmethods */);
+  MarkingNMethodClosure code_closure(marker->mark_closure(), !NMethodToOopClosure::FixRelocations, true /* keepalive nmethods */);
 
   if (ClassUnloading) {
     _root_processor.process_strong_roots(marker->mark_closure(),

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

@@ -286,7 +286,7 @@ void HeapRegion::remove_code_root(nmethod* nm) {
   rem_set()->remove_code_root(nm);
 }
 
-void HeapRegion::code_roots_do(CodeBlobClosure* blk) const {
+void HeapRegion::code_roots_do(NMethodClosure* blk) const {
   rem_set()->code_roots_do(blk);
 }
 
@@ -328,28 +328,27 @@ class VerifyCodeRootOopClosure: public OopClosure {
   bool has_oops_in_region() { return _has_oops_in_region; }
 };
 
-class VerifyCodeRootCodeBlobClosure: public CodeBlobClosure {
+class VerifyCodeRootNMethodClosure: public NMethodClosure {
   const HeapRegion* _hr;
   bool _failures;
 public:
-  VerifyCodeRootCodeBlobClosure(const HeapRegion* hr) :
+  VerifyCodeRootNMethodClosure(const HeapRegion* hr) :
     _hr(hr), _failures(false) {}
 
-  void do_code_blob(CodeBlob* cb) {
-    nmethod* nm = (cb == nullptr) ? nullptr : cb->as_nmethod_or_null();
-    if (nm != nullptr) {
-      // Verify that the nemthod is live
-      VerifyCodeRootOopClosure oop_cl(_hr);
-      nm->oops_do(&oop_cl);
-      if (!oop_cl.has_oops_in_region()) {
-        log_error(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has nmethod " PTR_FORMAT " in its code roots with no pointers into region",
-                              p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
-        _failures = true;
-      } else if (oop_cl.failures()) {
-        log_error(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has other failures for nmethod " PTR_FORMAT,
-                              p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
-        _failures = true;
-      }
+  void do_nmethod(nmethod* nm) {
+    assert(nm != nullptr, "Sanity");
+
+    // Verify that the nmethod is live
+    VerifyCodeRootOopClosure oop_cl(_hr);
+    nm->oops_do(&oop_cl);
+    if (!oop_cl.has_oops_in_region()) {
+      log_error(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has nmethod " PTR_FORMAT " in its code roots with no pointers into region",
+          p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
+      _failures = true;
+    } else if (oop_cl.failures()) {
+      log_error(gc, verify)("region [" PTR_FORMAT "," PTR_FORMAT "] has other failures for nmethod " PTR_FORMAT,
+          p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
+      _failures = true;
     }
   }
 
@@ -395,10 +394,10 @@ bool HeapRegion::verify_code_roots(VerifyOption vo) const {
     return has_code_roots;
   }
 
-  VerifyCodeRootCodeBlobClosure cb_cl(this);
-  code_roots_do(&cb_cl);
+  VerifyCodeRootNMethodClosure nm_cl(this);
+  code_roots_do(&nm_cl);
 
-  return cb_cl.failures();
+  return nm_cl.failures();
 }
 
 void HeapRegion::print() const { print_on(tty); }

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

@@ -540,9 +540,9 @@ class HeapRegion : public CHeapObj<mtGC> {
   void add_code_root(nmethod* nm);
   void remove_code_root(nmethod* nm);
 
-  // Applies blk->do_code_blob() to each of the entries in
+  // Applies blk->do_nmethod() to each of the entries in
   // the code roots list for this region
-  void code_roots_do(CodeBlobClosure* blk) const;
+  void code_roots_do(NMethodClosure* blk) const;
 
   uint node_index() const { return _node_index; }
   void set_node_index(uint node_index) { _node_index = node_index; }

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

@@ -119,7 +119,7 @@ void HeapRegionRemSet::bulk_remove_code_roots() {
   _code_roots.bulk_remove();
 }
 
-void HeapRegionRemSet::code_roots_do(CodeBlobClosure* blk) const {
+void HeapRegionRemSet::code_roots_do(NMethodClosure* blk) const {
   _code_roots.nmethods_do(blk);
 }