48 
  49 void ScavengeRootsTask::do_it(GCTaskManager* manager, uint which) {
  50   assert(Universe::heap()->is_gc_active(), "called outside gc");
  51 
  52   PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which);
  53   PSScavengeRootsClosure roots_closure(pm);
  54   PSPromoteRootsClosure  roots_to_old_closure(pm);
  55 
  56   switch (_root_type) {
  57     case universe:
  58       Universe::oops_do(&roots_closure);
  59       break;
  60 
  61     case jni_handles:
  62       JNIHandles::oops_do(&roots_closure);
  63       break;
  64 
  65     case threads:
  66     {
  67       ResourceMark rm;
  68       Threads::oops_do(&roots_closure, NULL);

  69     }
  70     break;
  71 
  72     case object_synchronizer:
  73       ObjectSynchronizer::oops_do(&roots_closure);
  74       break;
  75 
  76     case flat_profiler:
  77       FlatProfiler::oops_do(&roots_closure);
  78       break;
  79 
  80     case system_dictionary:
  81       {
  82       SystemDictionary::oops_do(&roots_closure);
  83 
  84         // Move this to another root_type?
  85         PSScavengeKlassClosure klass_closure(pm);
  86         ClassLoaderDataGraph::oops_do(&roots_closure, &klass_closure, false);
  87       }
  88       break;

 103       }
 104       break;
 105 
 106     default:
 107       fatal("Unknown root type");
 108   }
 109 
 110   // Do the real work
 111   pm->drain_stacks(false);
 112 }
 113 
 114 //
 115 // ThreadRootsTask
 116 //
 117 
 118 void ThreadRootsTask::do_it(GCTaskManager* manager, uint which) {
 119   assert(Universe::heap()->is_gc_active(), "called outside gc");
 120 
 121   PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which);
 122   PSScavengeRootsClosure roots_closure(pm);

 123   CodeBlobToOopClosure roots_in_blobs(&roots_closure, /*do_marking=*/ true);
 124 
 125   if (_java_thread != NULL)
 126     _java_thread->oops_do(&roots_closure, &roots_in_blobs);
 127 
 128   if (_vm_thread != NULL)
 129     _vm_thread->oops_do(&roots_closure, &roots_in_blobs);
 130 
 131   // Do the real work
 132   pm->drain_stacks(false);
 133 }
 134 
 135 //
 136 // StealTask
 137 //
 138 
 139 StealTask::StealTask(ParallelTaskTerminator* t) :
 140   _terminator(t) {}
 141 
 142 void StealTask::do_it(GCTaskManager* manager, uint which) {
 143   assert(Universe::heap()->is_gc_active(), "called outside gc");
 144 
 145   PSPromotionManager* pm =
 146     PSPromotionManager::gc_thread_promotion_manager(which);
 147   pm->drain_stacks(true);
 148   guarantee(pm->stacks_empty(),
 149             "stacks should be empty at this point");

  48 
  49 void ScavengeRootsTask::do_it(GCTaskManager* manager, uint which) {
  50   assert(Universe::heap()->is_gc_active(), "called outside gc");
  51 
  52   PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which);
  53   PSScavengeRootsClosure roots_closure(pm);
  54   PSPromoteRootsClosure  roots_to_old_closure(pm);
  55 
  56   switch (_root_type) {
  57     case universe:
  58       Universe::oops_do(&roots_closure);
  59       break;
  60 
  61     case jni_handles:
  62       JNIHandles::oops_do(&roots_closure);
  63       break;
  64 
  65     case threads:
  66     {
  67       ResourceMark rm;
  68       CLDToOopClosure* cld_closure = NULL; // Not needed. All CLDs are already visited.
  69       Threads::oops_do(&roots_closure, cld_closure, NULL);
  70     }
  71     break;
  72 
  73     case object_synchronizer:
  74       ObjectSynchronizer::oops_do(&roots_closure);
  75       break;
  76 
  77     case flat_profiler:
  78       FlatProfiler::oops_do(&roots_closure);
  79       break;
  80 
  81     case system_dictionary:
  82       {
  83       SystemDictionary::oops_do(&roots_closure);
  84 
  85         // Move this to another root_type?
  86         PSScavengeKlassClosure klass_closure(pm);
  87         ClassLoaderDataGraph::oops_do(&roots_closure, &klass_closure, false);
  88       }
  89       break;

 104       }
 105       break;
 106 
 107     default:
 108       fatal("Unknown root type");
 109   }
 110 
 111   // Do the real work
 112   pm->drain_stacks(false);
 113 }
 114 
 115 //
 116 // ThreadRootsTask
 117 //
 118 
 119 void ThreadRootsTask::do_it(GCTaskManager* manager, uint which) {
 120   assert(Universe::heap()->is_gc_active(), "called outside gc");
 121 
 122   PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which);
 123   PSScavengeRootsClosure roots_closure(pm);
 124   CLDToOopClosure* roots_from_clds = NULL;  // Not needed. All CLDs are already visited.
 125   CodeBlobToOopClosure roots_in_blobs(&roots_closure, /*do_marking=*/ true);
 126 
 127   if (_java_thread != NULL)
 128     _java_thread->oops_do(&roots_closure, roots_from_clds, &roots_in_blobs);
 129 
 130   if (_vm_thread != NULL)
 131     _vm_thread->oops_do(&roots_closure, roots_from_clds, &roots_in_blobs);
 132 
 133   // Do the real work
 134   pm->drain_stacks(false);
 135 }
 136 
 137 //
 138 // StealTask
 139 //
 140 
 141 StealTask::StealTask(ParallelTaskTerminator* t) :
 142   _terminator(t) {}
 143 
 144 void StealTask::do_it(GCTaskManager* manager, uint which) {
 145   assert(Universe::heap()->is_gc_active(), "called outside gc");
 146 
 147   PSPromotionManager* pm =
 148     PSPromotionManager::gc_thread_promotion_manager(which);
 149   pm->drain_stacks(true);
 150   guarantee(pm->stacks_empty(),
 151             "stacks should be empty at this point");