21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/systemDictionary.hpp"
  27 #include "code/codeCache.hpp"
  28 #include "gc/parallel/parallelScavengeHeap.hpp"
  29 #include "gc/parallel/pcTasks.hpp"
  30 #include "gc/parallel/psCompactionManager.inline.hpp"
  31 #include "gc/parallel/psParallelCompact.hpp"
  32 #include "gc/shared/collectedHeap.hpp"
  33 #include "gc/shared/gcTimer.hpp"
  34 #include "gc/shared/gcTraceTime.inline.hpp"
  35 #include "logging/log.hpp"
  36 #include "memory/resourceArea.hpp"
  37 #include "memory/universe.hpp"
  38 #include "oops/objArrayKlass.inline.hpp"
  39 #include "oops/oop.inline.hpp"
  40 #include "prims/jvmtiExport.hpp"

  41 #include "runtime/fprofiler.hpp"
  42 #include "runtime/jniHandles.hpp"
  43 #include "runtime/thread.hpp"
  44 #include "runtime/vmThread.hpp"
  45 #include "services/management.hpp"
  46 #include "utilities/stack.inline.hpp"
  47 
  48 //
  49 // ThreadRootsMarkingTask
  50 //
  51 
  52 void ThreadRootsMarkingTask::do_it(GCTaskManager* manager, uint which) {
  53   assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  54 
  55   ResourceMark rm;
  56 
  57   ParCompactionManager* cm =
  58     ParCompactionManager::gc_thread_compaction_manager(which);
  59 
  60   ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);

 110 
 111     case management:
 112       Management::oops_do(&mark_and_push_closure);
 113       break;
 114 
 115     case jvmti:
 116       JvmtiExport::oops_do(&mark_and_push_closure);
 117       break;
 118 
 119     case system_dictionary:
 120       SystemDictionary::always_strong_oops_do(&mark_and_push_closure);
 121       break;
 122 
 123     case class_loader_data:
 124       ClassLoaderDataGraph::always_strong_oops_do(&mark_and_push_closure, &follow_klass_closure, true);
 125       break;
 126 
 127     case code_cache:
 128       // Do not treat nmethods as strong roots for mark/sweep, since we can unload them.
 129       //CodeCache::scavenge_root_nmethods_do(CodeBlobToOopClosure(&mark_and_push_closure));



 130       break;
 131 
 132     default:
 133       fatal("Unknown root type");
 134   }
 135 
 136   // Do the real work
 137   cm->follow_marking_stacks();
 138 }
 139 
 140 
 141 //
 142 // RefProcTaskProxy
 143 //
 144 
 145 void RefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
 146 {
 147   assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
 148 
 149   ParCompactionManager* cm =

  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/systemDictionary.hpp"
  27 #include "code/codeCache.hpp"
  28 #include "gc/parallel/parallelScavengeHeap.hpp"
  29 #include "gc/parallel/pcTasks.hpp"
  30 #include "gc/parallel/psCompactionManager.inline.hpp"
  31 #include "gc/parallel/psParallelCompact.hpp"
  32 #include "gc/shared/collectedHeap.hpp"
  33 #include "gc/shared/gcTimer.hpp"
  34 #include "gc/shared/gcTraceTime.inline.hpp"
  35 #include "logging/log.hpp"
  36 #include "memory/resourceArea.hpp"
  37 #include "memory/universe.hpp"
  38 #include "oops/objArrayKlass.inline.hpp"
  39 #include "oops/oop.inline.hpp"
  40 #include "prims/jvmtiExport.hpp"
  41 #include "aot/aotLoader.hpp"
  42 #include "runtime/fprofiler.hpp"
  43 #include "runtime/jniHandles.hpp"
  44 #include "runtime/thread.hpp"
  45 #include "runtime/vmThread.hpp"
  46 #include "services/management.hpp"
  47 #include "utilities/stack.inline.hpp"
  48 
  49 //
  50 // ThreadRootsMarkingTask
  51 //
  52 
  53 void ThreadRootsMarkingTask::do_it(GCTaskManager* manager, uint which) {
  54   assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
  55 
  56   ResourceMark rm;
  57 
  58   ParCompactionManager* cm =
  59     ParCompactionManager::gc_thread_compaction_manager(which);
  60 
  61   ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);

 111 
 112     case management:
 113       Management::oops_do(&mark_and_push_closure);
 114       break;
 115 
 116     case jvmti:
 117       JvmtiExport::oops_do(&mark_and_push_closure);
 118       break;
 119 
 120     case system_dictionary:
 121       SystemDictionary::always_strong_oops_do(&mark_and_push_closure);
 122       break;
 123 
 124     case class_loader_data:
 125       ClassLoaderDataGraph::always_strong_oops_do(&mark_and_push_closure, &follow_klass_closure, true);
 126       break;
 127 
 128     case code_cache:
 129       // Do not treat nmethods as strong roots for mark/sweep, since we can unload them.
 130       //CodeCache::scavenge_root_nmethods_do(CodeBlobToOopClosure(&mark_and_push_closure));
 131       if (UseAOT) {
 132         AOTLoader::oops_do(&mark_and_push_closure);
 133       }
 134       break;
 135 
 136     default:
 137       fatal("Unknown root type");
 138   }
 139 
 140   // Do the real work
 141   cm->follow_marking_stacks();
 142 }
 143 
 144 
 145 //
 146 // RefProcTaskProxy
 147 //
 148 
 149 void RefProcTaskProxy::do_it(GCTaskManager* manager, uint which)
 150 {
 151   assert(ParallelScavengeHeap::heap()->is_gc_active(), "called outside gc");
 152 
 153   ParCompactionManager* cm =