src/share/vm/jfr/leakprofiler/chains/rootSetClosure.cpp

rev 9055 : 8214542: JFR: Old Object Sample event slow on a deep heap in debug builds
Reviewed-by: egahlin, rwestberg

*** 23,49 ****
   */
  
  #include "precompiled.hpp"
  #include "classfile/classLoaderData.hpp"
  #include "classfile/systemDictionary.hpp"
  #include "jfr/leakprofiler/chains/edgeQueue.hpp"
  #include "jfr/leakprofiler/chains/rootSetClosure.hpp"
  #include "jfr/leakprofiler/utilities/saveRestore.hpp"
  #include "jfr/leakprofiler/utilities/unifiedOop.hpp"
  #include "memory/universe.hpp"
  #include "prims/jvmtiExport.hpp"
  #include "runtime/jniHandles.hpp"
  #include "runtime/synchronizer.hpp"
  #include "runtime/thread.hpp"
  #include "services/management.hpp"
  #include "utilities/align.hpp"
  
! RootSetClosure::RootSetClosure(EdgeQueue* edge_queue) :
!   _edge_queue(edge_queue) {
! }
  
! void RootSetClosure::do_oop(oop* ref) {
    assert(ref != NULL, "invariant");
    // We discard unaligned root references because
    // our reference tagging scheme will use
    // the lowest bit in a represented reference
    // to indicate the reference is narrow.
--- 23,52 ----
   */
  
  #include "precompiled.hpp"
  #include "classfile/classLoaderData.hpp"
  #include "classfile/systemDictionary.hpp"
+ #include "jfr/leakprofiler/chains/bfsClosure.hpp"
+ #include "jfr/leakprofiler/chains/dfsClosure.hpp"
  #include "jfr/leakprofiler/chains/edgeQueue.hpp"
  #include "jfr/leakprofiler/chains/rootSetClosure.hpp"
  #include "jfr/leakprofiler/utilities/saveRestore.hpp"
  #include "jfr/leakprofiler/utilities/unifiedOop.hpp"
  #include "memory/universe.hpp"
+ #include "oops/oop.inline.hpp"
  #include "prims/jvmtiExport.hpp"
  #include "runtime/jniHandles.hpp"
  #include "runtime/synchronizer.hpp"
  #include "runtime/thread.hpp"
  #include "services/management.hpp"
  #include "utilities/align.hpp"
  
! template <typename Delegate>
! RootSetClosure<Delegate>::RootSetClosure(Delegate* delegate) : _delegate(delegate) {}
  
! template <typename Delegate>
! void RootSetClosure<Delegate>::do_oop(oop* ref) {
    assert(ref != NULL, "invariant");
    // We discard unaligned root references because
    // our reference tagging scheme will use
    // the lowest bit in a represented reference
    // to indicate the reference is narrow.
*** 53,102 ****
    if (!is_aligned(ref, HeapWordSize)) {
      return;
    }
  
    assert(is_aligned(ref, HeapWordSize), "invariant");
!   const oop pointee = *ref;
!   if (pointee != NULL) {
!     closure_impl(ref, pointee);
    }
  }
  
! void RootSetClosure::do_oop(narrowOop* ref) {
    assert(ref != NULL, "invariant");
    assert(is_aligned(ref, sizeof(narrowOop)), "invariant");
    const oop pointee = oopDesc::load_decode_heap_oop(ref);
    if (pointee != NULL) {
!     closure_impl(UnifiedOop::encode(ref), pointee);
    }
  }
  
! void RootSetClosure::closure_impl(const oop* reference, const oop pointee) {
!   if (!_edge_queue->is_full())  {
!     _edge_queue->add(NULL, reference);
!   }
! }
  
! void RootSetClosure::add_to_queue(EdgeQueue* edge_queue) {
!   RootSetClosure rs(edge_queue);
!   process_roots(&rs);
! }
! 
! class RootSetClosureMarkScope : public MarkingCodeBlobClosure::MarkScope {
! };
! 
! void RootSetClosure::process_roots(OopClosure* closure) {
!   SaveRestoreCLDClaimBits save_restore_cld_claim_bits;
    RootSetClosureMarkScope mark_scope;
! 
!   CLDToOopClosure cldt_closure(closure);
    ClassLoaderDataGraph::always_strong_cld_do(&cldt_closure);
!   CodeBlobToOopClosure blobs(closure, false);
!   Threads::oops_do(closure, NULL, &blobs); // XXX set CLDClosure to NULL
!   ObjectSynchronizer::oops_do(closure);
!   Universe::oops_do(closure);
!   JNIHandles::oops_do(closure);
!   JvmtiExport::oops_do(closure);
!   SystemDictionary::oops_do(closure);
!   Management::oops_do(closure);
!   StringTable::oops_do(closure);
  }
--- 56,95 ----
    if (!is_aligned(ref, HeapWordSize)) {
      return;
    }
  
    assert(is_aligned(ref, HeapWordSize), "invariant");
!   if (*ref != NULL) {
!     _delegate->do_root(ref);
    }
  }
  
! template <typename Delegate>
! void RootSetClosure<Delegate>::do_oop(narrowOop* ref) {
    assert(ref != NULL, "invariant");
    assert(is_aligned(ref, sizeof(narrowOop)), "invariant");
    const oop pointee = oopDesc::load_decode_heap_oop(ref);
    if (pointee != NULL) {
!     _delegate->do_root(UnifiedOop::encode(ref));
    }
  }
  
! class RootSetClosureMarkScope : public MarkingCodeBlobClosure::MarkScope {};
  
! template <typename Delegate>
! void RootSetClosure<Delegate>::process() {
    RootSetClosureMarkScope mark_scope;
!   CLDToOopClosure cldt_closure(this);
    ClassLoaderDataGraph::always_strong_cld_do(&cldt_closure);
!   CodeBlobToOopClosure blobs(this, false);
!   Threads::oops_do(this, NULL, &blobs); // XXX set CLDClosure to NULL
!   ObjectSynchronizer::oops_do(this);
!   Universe::oops_do(this);
!   JNIHandles::oops_do(this);
!   JvmtiExport::oops_do(this);
!   SystemDictionary::oops_do(this);
!   Management::oops_do(this);
!   StringTable::oops_do(this);
  }
+ 
+ template class RootSetClosure<BFSClosure>;
+ template class RootSetClosure<DFSClosure>;