1 #ifdef USE_PRAGMA_IDENT_HDR
   2 #pragma ident "@(#)parOopClosures.hpp   1.2 07/06/22 16:49:48 JVM"
   3 #endif
   4 /*
   5  * Copyright (c) 2007 Sun Microsystems, Inc.  All Rights Reserved.
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *   
   8  * This code is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License version 2 only, as
  10  * published by the Free Software Foundation.
  11  *   
  12  * This code is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15  * version 2 for more details (a copy is included in the LICENSE file that
  16  * accompanied this code).
  17  *  
  18  * You should have received a copy of the GNU General Public License version
  19  * 2 along with this work; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *   
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *  
  26  */
  27 
  28 // Closures for ParNewGeneration
  29 
  30 class ParScanThreadState;
  31 class ParNewGeneration;
  32 typedef OopTaskQueueSet ObjToScanQueueSet;
  33 class ParallelTaskTerminator;
  34 
  35 class ParScanClosure: public OopsInGenClosure {
  36  protected:
  37   ParScanThreadState* _par_scan_state;
  38   ParNewGeneration*   _g;
  39   HeapWord*           _boundary;
  40   template <class T> void inline par_do_barrier(T* p);
  41   template <class T> void inline do_oop_work(T* p,
  42                                              bool gc_barrier,
  43                                              bool root_scan);
  44  public:
  45   ParScanClosure(ParNewGeneration* g, ParScanThreadState* par_scan_state);
  46 };
  47 
  48 class ParScanWithBarrierClosure: public ParScanClosure {
  49  public:
  50   ParScanWithBarrierClosure(ParNewGeneration* g,
  51                             ParScanThreadState* par_scan_state) :
  52     ParScanClosure(g, par_scan_state) {}
  53   virtual void do_oop(oop* p);
  54   virtual void do_oop(narrowOop* p);
  55   inline void do_oop_nv(oop* p);
  56   inline void do_oop_nv(narrowOop* p);
  57 };
  58 
  59 class ParScanWithoutBarrierClosure: public ParScanClosure {
  60  public:
  61   ParScanWithoutBarrierClosure(ParNewGeneration* g,
  62                                ParScanThreadState* par_scan_state) :
  63     ParScanClosure(g, par_scan_state) {}
  64   virtual void do_oop(oop* p);
  65   virtual void do_oop(narrowOop* p);
  66   inline void do_oop_nv(oop* p);
  67   inline void do_oop_nv(narrowOop* p);
  68 };
  69 
  70 class ParRootScanWithBarrierTwoGensClosure: public ParScanClosure {
  71  public:
  72   ParRootScanWithBarrierTwoGensClosure(ParNewGeneration* g,
  73                                        ParScanThreadState* par_scan_state) :
  74     ParScanClosure(g, par_scan_state) {}
  75   virtual void do_oop(oop* p);
  76   virtual void do_oop(narrowOop* p);
  77 };
  78 
  79 class ParRootScanWithoutBarrierClosure: public ParScanClosure {
  80  public:
  81   ParRootScanWithoutBarrierClosure(ParNewGeneration* g,
  82                                    ParScanThreadState* par_scan_state) :
  83     ParScanClosure(g, par_scan_state) {}
  84   virtual void do_oop(oop* p);
  85   virtual void do_oop(narrowOop* p);
  86 };
  87 
  88 class ParScanWeakRefClosure: public ScanWeakRefClosure {
  89  protected:
  90   ParScanThreadState* _par_scan_state;
  91   template <class T> inline void do_oop_work(T* p);
  92  public:
  93   ParScanWeakRefClosure(ParNewGeneration* g,
  94                         ParScanThreadState* par_scan_state);
  95   virtual void do_oop(oop* p);
  96   virtual void do_oop(narrowOop* p);
  97   inline void do_oop_nv(oop* p);
  98   inline void do_oop_nv(narrowOop* p);
  99 };
 100 
 101 class ParEvacuateFollowersClosure: public VoidClosure {
 102  private:
 103   ParScanThreadState* _par_scan_state;
 104   ParScanThreadState* par_scan_state() { return _par_scan_state; }
 105 
 106   // We want to preserve the specific types here (rather than "OopClosure") 
 107   // for later de-virtualization of do_oop calls.
 108   ParScanWithoutBarrierClosure* _to_space_closure;
 109   ParScanWithoutBarrierClosure* to_space_closure() {
 110     return _to_space_closure;
 111   }
 112   ParRootScanWithoutBarrierClosure* _to_space_root_closure;
 113   ParRootScanWithoutBarrierClosure* to_space_root_closure() {
 114     return _to_space_root_closure;
 115   }
 116 
 117   ParScanWithBarrierClosure* _old_gen_closure;
 118   ParScanWithBarrierClosure* old_gen_closure () {
 119     return _old_gen_closure;
 120   }
 121   ParRootScanWithBarrierTwoGensClosure* _old_gen_root_closure;
 122   ParRootScanWithBarrierTwoGensClosure* old_gen_root_closure () {
 123     return _old_gen_root_closure;
 124   }
 125 
 126   ParNewGeneration* _par_gen;
 127   ParNewGeneration* par_gen() { return _par_gen; }
 128   
 129   ObjToScanQueueSet*  _task_queues;
 130   ObjToScanQueueSet*  task_queues() { return _task_queues; }
 131 
 132   ParallelTaskTerminator* _terminator;
 133   ParallelTaskTerminator* terminator() { return _terminator; }
 134  public:
 135   ParEvacuateFollowersClosure(
 136     ParScanThreadState* par_scan_state_,
 137     ParScanWithoutBarrierClosure* to_space_closure_,
 138     ParScanWithBarrierClosure* old_gen_closure_,
 139     ParRootScanWithoutBarrierClosure* to_space_root_closure_,
 140     ParNewGeneration* par_gen_,
 141     ParRootScanWithBarrierTwoGensClosure* old_gen_root_closure_,
 142     ObjToScanQueueSet* task_queues_,
 143     ParallelTaskTerminator* terminator_);
 144   virtual void do_void();
 145 };