src/share/vm/memory/barrierSet.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File g1-bulk-zeroing-reduction Sdiff src/share/vm/memory

src/share/vm/memory/barrierSet.hpp

Print this page


   1 /*
   2  * Copyright (c) 2000, 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  *


  27 
  28 #include "memory/memRegion.hpp"
  29 #include "oops/oopsHierarchy.hpp"
  30 
  31 // This class provides the interface between a barrier implementation and
  32 // the rest of the system.
  33 
  34 class BarrierSet: public CHeapObj {
  35   friend class VMStructs;
  36 public:
  37   enum Name {
  38     ModRef,
  39     CardTableModRef,
  40     CardTableExtension,
  41     G1SATBCT,
  42     G1SATBCTLogging,
  43     Other,
  44     Uninit
  45   };
  46 




  47 protected:
  48   int _max_covered_regions;
  49   Name _kind;
  50 
  51 public:
  52 
  53   BarrierSet() { _kind = Uninit; }
  54   // To get around prohibition on RTTI.
  55   BarrierSet::Name kind() { return _kind; }
  56   virtual bool is_a(BarrierSet::Name bsn) = 0;
  57 
  58   // These operations indicate what kind of barriers the BarrierSet has.
  59   virtual bool has_read_ref_barrier() = 0;
  60   virtual bool has_read_prim_barrier() = 0;
  61   virtual bool has_write_ref_barrier() = 0;
  62   virtual bool has_write_ref_pre_barrier() = 0;
  63   virtual bool has_write_prim_barrier() = 0;
  64 
  65   // These functions indicate whether a particular access of the given
  66   // kinds requires a barrier.


 111   // optimized by some barriers.
 112 
 113   // The first six operations tell whether such an optimization exists for
 114   // the particular barrier.
 115   virtual bool has_read_ref_array_opt() = 0;
 116   virtual bool has_read_prim_array_opt() = 0;
 117   virtual bool has_write_ref_array_pre_opt() { return true; }
 118   virtual bool has_write_ref_array_opt() = 0;
 119   virtual bool has_write_prim_array_opt() = 0;
 120 
 121   virtual bool has_read_region_opt() = 0;
 122   virtual bool has_write_region_opt() = 0;
 123 
 124   // These operations should assert false unless the correponding operation
 125   // above returns true.  Otherwise, they should perform an appropriate
 126   // barrier for an array whose elements are all in the given memory region.
 127   virtual void read_ref_array(MemRegion mr) = 0;
 128   virtual void read_prim_array(MemRegion mr) = 0;
 129 
 130   // Below length is the # array elements being written
 131   virtual void write_ref_array_pre(      oop* dst, int length) {}
 132   virtual void write_ref_array_pre(narrowOop* dst, int length) {}


 133   // Below count is the # array elements being written, starting
 134   // at the address "start", which may not necessarily be HeapWord-aligned
 135   inline void write_ref_array(HeapWord* start, size_t count);
 136 
 137   // Static versions, suitable for calling from generated code;
 138   // count is # array elements being written, starting with "start",
 139   // which may not necessarily be HeapWord-aligned.
 140   static void static_write_ref_array_pre(HeapWord* start, size_t count);
 141   static void static_write_ref_array_post(HeapWord* start, size_t count);
 142 
 143 protected:
 144   virtual void write_ref_array_work(MemRegion mr) = 0;
 145 public:
 146   virtual void write_prim_array(MemRegion mr) = 0;
 147 
 148   virtual void read_region(MemRegion mr) = 0;
 149 
 150   // (For efficiency reasons, this operation is specialized for certain
 151   // barrier types.  Semantically, it should be thought of as a call to the
 152   // virtual "_work" function below, which must implement the barrier.)


   1 /*
   2  * Copyright (c) 2000, 2011, 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  *


  27 
  28 #include "memory/memRegion.hpp"
  29 #include "oops/oopsHierarchy.hpp"
  30 
  31 // This class provides the interface between a barrier implementation and
  32 // the rest of the system.
  33 
  34 class BarrierSet: public CHeapObj {
  35   friend class VMStructs;
  36 public:
  37   enum Name {
  38     ModRef,
  39     CardTableModRef,
  40     CardTableExtension,
  41     G1SATBCT,
  42     G1SATBCTLogging,
  43     Other,
  44     Uninit
  45   };
  46 
  47   enum Flags {
  48     None                = 0,
  49     TargetUninitialized = 1
  50   };
  51 protected:
  52   int _max_covered_regions;
  53   Name _kind;
  54 
  55 public:
  56 
  57   BarrierSet() { _kind = Uninit; }
  58   // To get around prohibition on RTTI.
  59   BarrierSet::Name kind() { return _kind; }
  60   virtual bool is_a(BarrierSet::Name bsn) = 0;
  61 
  62   // These operations indicate what kind of barriers the BarrierSet has.
  63   virtual bool has_read_ref_barrier() = 0;
  64   virtual bool has_read_prim_barrier() = 0;
  65   virtual bool has_write_ref_barrier() = 0;
  66   virtual bool has_write_ref_pre_barrier() = 0;
  67   virtual bool has_write_prim_barrier() = 0;
  68 
  69   // These functions indicate whether a particular access of the given
  70   // kinds requires a barrier.


 115   // optimized by some barriers.
 116 
 117   // The first six operations tell whether such an optimization exists for
 118   // the particular barrier.
 119   virtual bool has_read_ref_array_opt() = 0;
 120   virtual bool has_read_prim_array_opt() = 0;
 121   virtual bool has_write_ref_array_pre_opt() { return true; }
 122   virtual bool has_write_ref_array_opt() = 0;
 123   virtual bool has_write_prim_array_opt() = 0;
 124 
 125   virtual bool has_read_region_opt() = 0;
 126   virtual bool has_write_region_opt() = 0;
 127 
 128   // These operations should assert false unless the correponding operation
 129   // above returns true.  Otherwise, they should perform an appropriate
 130   // barrier for an array whose elements are all in the given memory region.
 131   virtual void read_ref_array(MemRegion mr) = 0;
 132   virtual void read_prim_array(MemRegion mr) = 0;
 133 
 134   // Below length is the # array elements being written
 135   virtual void write_ref_array_pre(oop* dst, int length,
 136                                    bool dest_uninitialized = false) {}
 137   virtual void write_ref_array_pre(narrowOop* dst, int length,
 138                                    bool dest_uninitialized = false) {}
 139   // Below count is the # array elements being written, starting
 140   // at the address "start", which may not necessarily be HeapWord-aligned
 141   inline void write_ref_array(HeapWord* start, size_t count);
 142 
 143   // Static versions, suitable for calling from generated code;
 144   // count is # array elements being written, starting with "start",
 145   // which may not necessarily be HeapWord-aligned.
 146   static void static_write_ref_array_pre(HeapWord* start, size_t count);
 147   static void static_write_ref_array_post(HeapWord* start, size_t count);
 148 
 149 protected:
 150   virtual void write_ref_array_work(MemRegion mr) = 0;
 151 public:
 152   virtual void write_prim_array(MemRegion mr) = 0;
 153 
 154   virtual void read_region(MemRegion mr) = 0;
 155 
 156   // (For efficiency reasons, this operation is specialized for certain
 157   // barrier types.  Semantically, it should be thought of as a call to the
 158   // virtual "_work" function below, which must implement the barrier.)


src/share/vm/memory/barrierSet.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File