< prev index next >

src/share/vm/gc/g1/g1RootProcessor.hpp

Print this page
rev 11972 : 8114823: G1 doesn't honor request to disable class unloading
Reviewed-by:
rev 11973 : [mq]: 8114823-disable-cls-new-process-tschatzl-rev1


  56 
  57   enum G1H_process_roots_tasks {
  58     G1RP_PS_Universe_oops_do,
  59     G1RP_PS_JNIHandles_oops_do,
  60     G1RP_PS_ObjectSynchronizer_oops_do,
  61     G1RP_PS_FlatProfiler_oops_do,
  62     G1RP_PS_Management_oops_do,
  63     G1RP_PS_SystemDictionary_oops_do,
  64     G1RP_PS_ClassLoaderDataGraph_oops_do,
  65     G1RP_PS_jvmti_oops_do,
  66     G1RP_PS_CodeCache_oops_do,
  67     G1RP_PS_filter_satb_buffers,
  68     G1RP_PS_refProcessor_oops_do,
  69     // Leave this one last.
  70     G1RP_PS_NumElements
  71   };
  72 
  73   void worker_has_discovered_all_strong_classes();
  74   void wait_until_all_strong_classes_discovered();
  75 





  76   void process_java_roots(G1RootClosures* closures,
  77                           G1GCPhaseTimes* phase_times,
  78                           uint worker_i);
  79 
  80   void process_vm_roots(G1RootClosures* closures,
  81                         G1GCPhaseTimes* phase_times,
  82                         uint worker_i);
  83 








  84 public:
  85   G1RootProcessor(G1CollectedHeap* g1h, uint n_workers);
  86 
  87   // Apply closures to the strongly and weakly reachable roots in the system
  88   // in a single pass.
  89   // Record and report timing measurements for sub phases using the worker_i
  90   void evacuate_roots(G1EvacuationRootClosures* closures, uint worker_i);
  91 
  92   // Apply oops, clds and blobs to all strongly reachable roots in the system
  93   void process_strong_roots(OopClosure* oops,
  94                             CLDClosure* clds,
  95                             CodeBlobClosure* blobs);
  96 
  97   // Apply oops, clds and blobs to strongly and weakly reachable roots in the system
  98   void process_all_roots(OopClosure* oops,
  99                          CLDClosure* clds,
 100                          CodeBlobClosure* blobs);







 101 
 102   // Number of worker threads used by the root processor.
 103   uint n_workers() const;
 104 };
 105 
 106 #endif // SHARE_VM_GC_G1_G1ROOTPROCESSOR_HPP


  56 
  57   enum G1H_process_roots_tasks {
  58     G1RP_PS_Universe_oops_do,
  59     G1RP_PS_JNIHandles_oops_do,
  60     G1RP_PS_ObjectSynchronizer_oops_do,
  61     G1RP_PS_FlatProfiler_oops_do,
  62     G1RP_PS_Management_oops_do,
  63     G1RP_PS_SystemDictionary_oops_do,
  64     G1RP_PS_ClassLoaderDataGraph_oops_do,
  65     G1RP_PS_jvmti_oops_do,
  66     G1RP_PS_CodeCache_oops_do,
  67     G1RP_PS_filter_satb_buffers,
  68     G1RP_PS_refProcessor_oops_do,
  69     // Leave this one last.
  70     G1RP_PS_NumElements
  71   };
  72 
  73   void worker_has_discovered_all_strong_classes();
  74   void wait_until_all_strong_classes_discovered();
  75 
  76   void process_all_roots(OopClosure* oops,
  77                          CLDClosure* clds,
  78                          CodeBlobClosure* blobs,
  79                          bool process_string_table);
  80 
  81   void process_java_roots(G1RootClosures* closures,
  82                           G1GCPhaseTimes* phase_times,
  83                           uint worker_i);
  84 
  85   void process_vm_roots(G1RootClosures* closures,
  86                         G1GCPhaseTimes* phase_times,
  87                         uint worker_i);
  88 
  89   void process_string_table_roots(G1RootClosures* closures,
  90                                   G1GCPhaseTimes* phase_times,
  91                                   uint worker_i);
  92 
  93   void process_code_cache_roots(CodeBlobClosure* code_closure,
  94                                 G1GCPhaseTimes* phase_times,
  95                                 uint worker_i);
  96 
  97 public:
  98   G1RootProcessor(G1CollectedHeap* g1h, uint n_workers);
  99 
 100   // Apply closures to the strongly and weakly reachable roots in the system
 101   // in a single pass.
 102   // Record and report timing measurements for sub phases using the worker_i
 103   void evacuate_roots(G1EvacuationRootClosures* closures, uint worker_i);
 104 
 105   // Apply oops, clds and blobs to all strongly reachable roots in the system
 106   void process_strong_roots(OopClosure* oops,
 107                             CLDClosure* clds,
 108                             CodeBlobClosure* blobs);
 109 
 110   // Apply oops, clds and blobs to strongly and weakly reachable roots in the system
 111   void process_all_roots(OopClosure* oops,
 112                          CLDClosure* clds,
 113                          CodeBlobClosure* blobs);
 114 
 115   // Apply oops, clds and blobs to strongly and weakly reachable roots in the system,
 116   // the only thing different from process_all_roots is that we skip the string table
 117   // to avoid keeping every string live when doing class unloading.
 118   void process_all_roots_no_string_table(OopClosure* oops,
 119                                          CLDClosure* clds,
 120                                          CodeBlobClosure* blobs);
 121 
 122   // Number of worker threads used by the root processor.
 123   uint n_workers() const;
 124 };
 125 
 126 #endif // SHARE_VM_GC_G1_G1ROOTPROCESSOR_HPP
< prev index next >