< prev index next >

src/share/vm/gc/shared/referenceProcessor.hpp

Print this page




 232   ReferencePolicy* setup_policy(bool always_clear) {
 233     _current_soft_ref_policy = always_clear ?
 234       _always_clear_soft_ref_policy : _default_soft_ref_policy;
 235     _current_soft_ref_policy->setup();   // snapshot the policy threshold
 236     return _current_soft_ref_policy;
 237   }
 238 
 239   // Process references with a certain reachability level.
 240   void process_discovered_reflist(DiscoveredList               refs_lists[],
 241                                   ReferencePolicy*             policy,
 242                                   bool                         clear_referent,
 243                                   BoolObjectClosure*           is_alive,
 244                                   OopClosure*                  keep_alive,
 245                                   VoidClosure*                 complete_gc,
 246                                   AbstractRefProcTaskExecutor* task_executor);
 247 
 248   void process_phaseJNI(BoolObjectClosure* is_alive,
 249                         OopClosure*        keep_alive,
 250                         VoidClosure*       complete_gc);
 251 





 252   // Work methods used by the method process_discovered_reflist
 253   // Phase1: keep alive all those referents that are otherwise
 254   // dead but which must be kept alive by policy (and their closure).
 255   void process_phase1(DiscoveredList&     refs_list,
 256                       ReferencePolicy*    policy,
 257                       BoolObjectClosure*  is_alive,
 258                       OopClosure*         keep_alive,
 259                       VoidClosure*        complete_gc);
 260   // Phase2: remove all those references whose referents are
 261   // reachable.
 262   inline void process_phase2(DiscoveredList&    refs_list,
 263                              BoolObjectClosure* is_alive,
 264                              OopClosure*        keep_alive,
 265                              VoidClosure*       complete_gc) {
 266     if (discovery_is_atomic()) {
 267       // complete_gc is ignored in this case for this phase
 268       pp2_work(refs_list, is_alive, keep_alive);
 269     } else {
 270       assert(complete_gc != NULL, "Error");
 271       pp2_work_concurrent_discovery(refs_list, is_alive,




 232   ReferencePolicy* setup_policy(bool always_clear) {
 233     _current_soft_ref_policy = always_clear ?
 234       _always_clear_soft_ref_policy : _default_soft_ref_policy;
 235     _current_soft_ref_policy->setup();   // snapshot the policy threshold
 236     return _current_soft_ref_policy;
 237   }
 238 
 239   // Process references with a certain reachability level.
 240   void process_discovered_reflist(DiscoveredList               refs_lists[],
 241                                   ReferencePolicy*             policy,
 242                                   bool                         clear_referent,
 243                                   BoolObjectClosure*           is_alive,
 244                                   OopClosure*                  keep_alive,
 245                                   VoidClosure*                 complete_gc,
 246                                   AbstractRefProcTaskExecutor* task_executor);
 247 
 248   void process_phaseJNI(BoolObjectClosure* is_alive,
 249                         OopClosure*        keep_alive,
 250                         VoidClosure*       complete_gc);
 251 
 252   size_t process_phaseHeapSampling(BoolObjectClosure* is_alive,
 253                                    OopClosure*        keep_alive,
 254                                    VoidClosure*       complete_gc,
 255                                    AbstractRefProcTaskExecutor* task_executor);
 256 
 257   // Work methods used by the method process_discovered_reflist
 258   // Phase1: keep alive all those referents that are otherwise
 259   // dead but which must be kept alive by policy (and their closure).
 260   void process_phase1(DiscoveredList&     refs_list,
 261                       ReferencePolicy*    policy,
 262                       BoolObjectClosure*  is_alive,
 263                       OopClosure*         keep_alive,
 264                       VoidClosure*        complete_gc);
 265   // Phase2: remove all those references whose referents are
 266   // reachable.
 267   inline void process_phase2(DiscoveredList&    refs_list,
 268                              BoolObjectClosure* is_alive,
 269                              OopClosure*        keep_alive,
 270                              VoidClosure*       complete_gc) {
 271     if (discovery_is_atomic()) {
 272       // complete_gc is ignored in this case for this phase
 273       pp2_work(refs_list, is_alive, keep_alive);
 274     } else {
 275       assert(complete_gc != NULL, "Error");
 276       pp2_work_concurrent_discovery(refs_list, is_alive,


< prev index next >