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