Mercurial > hg > truffle
annotate src/share/vm/memory/barrierSet.hpp @ 1091:6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
Summary: Introduced a new write_ref_array(HeapWords* start, size_t count) method that does the requisite MemRegion range calculation so (some of the) clients of the erstwhile write_ref_array(MemRegion mr) do not need to worry. This removed all external uses of array_size(), which was also simplified and made private. Asserts were added to catch other possible issues. Further, less essential, fixes stemming from this investigation are deferred to CR 6904516 (to follow shortly in hs17).
Reviewed-by: kvn, coleenp, jmasa
| author | ysr |
|---|---|
| date | Thu, 03 Dec 2009 15:01:57 -0800 |
| parents | df6caf649ff7 |
| children | 6484c4ee11cb |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 2000-2008 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // This class provides the interface between a barrier implementation and | |
| 26 // the rest of the system. | |
| 27 | |
| 28 class BarrierSet: public CHeapObj { | |
| 29 friend class VMStructs; | |
| 30 public: | |
| 31 enum Name { | |
| 32 ModRef, | |
| 33 CardTableModRef, | |
| 34 CardTableExtension, | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
35 G1SATBCT, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
36 G1SATBCTLogging, |
| 0 | 37 Other, |
| 38 Uninit | |
| 39 }; | |
| 40 | |
| 41 protected: | |
| 42 int _max_covered_regions; | |
| 43 Name _kind; | |
| 44 | |
| 45 public: | |
| 46 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
47 BarrierSet() { _kind = Uninit; } |
| 0 | 48 // To get around prohibition on RTTI. |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
49 BarrierSet::Name kind() { return _kind; } |
| 0 | 50 virtual bool is_a(BarrierSet::Name bsn) = 0; |
| 51 | |
| 52 // These operations indicate what kind of barriers the BarrierSet has. | |
| 53 virtual bool has_read_ref_barrier() = 0; | |
| 54 virtual bool has_read_prim_barrier() = 0; | |
| 55 virtual bool has_write_ref_barrier() = 0; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
56 virtual bool has_write_ref_pre_barrier() = 0; |
| 0 | 57 virtual bool has_write_prim_barrier() = 0; |
| 58 | |
| 59 // These functions indicate whether a particular access of the given | |
| 60 // kinds requires a barrier. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
61 virtual bool read_ref_needs_barrier(void* field) = 0; |
| 0 | 62 virtual bool read_prim_needs_barrier(HeapWord* field, size_t bytes) = 0; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
63 virtual bool write_ref_needs_barrier(void* field, oop new_val) = 0; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
64 virtual bool write_prim_needs_barrier(HeapWord* field, size_t bytes, |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
65 juint val1, juint val2) = 0; |
| 0 | 66 |
| 67 // The first four operations provide a direct implementation of the | |
| 68 // barrier set. An interpreter loop, for example, could call these | |
| 69 // directly, as appropriate. | |
| 70 | |
| 71 // Invoke the barrier, if any, necessary when reading the given ref field. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
72 virtual void read_ref_field(void* field) = 0; |
| 0 | 73 |
| 74 // Invoke the barrier, if any, necessary when reading the given primitive | |
| 75 // "field" of "bytes" bytes in "obj". | |
| 76 virtual void read_prim_field(HeapWord* field, size_t bytes) = 0; | |
| 77 | |
| 78 // Invoke the barrier, if any, necessary when writing "new_val" into the | |
| 79 // ref field at "offset" in "obj". | |
| 80 // (For efficiency reasons, this operation is specialized for certain | |
| 81 // barrier types. Semantically, it should be thought of as a call to the | |
| 82 // virtual "_work" function below, which must implement the barrier.) | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
83 // First the pre-write versions... |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
84 template <class T> inline void write_ref_field_pre(T* field, oop new_val); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
85 private: |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
86 // Keep this private so as to catch violations at build time. |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
87 virtual void write_ref_field_pre_work( void* field, oop new_val) { guarantee(false, "Not needed"); }; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
88 protected: |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
89 virtual void write_ref_field_pre_work( oop* field, oop new_val) {}; |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
90 virtual void write_ref_field_pre_work(narrowOop* field, oop new_val) {}; |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
91 public: |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
92 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
93 // ...then the post-write version. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
94 inline void write_ref_field(void* field, oop new_val); |
| 0 | 95 protected: |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
96 virtual void write_ref_field_work(void* field, oop new_val) = 0; |
| 0 | 97 public: |
| 98 | |
| 99 // Invoke the barrier, if any, necessary when writing the "bytes"-byte | |
| 100 // value(s) "val1" (and "val2") into the primitive "field". | |
| 101 virtual void write_prim_field(HeapWord* field, size_t bytes, | |
| 102 juint val1, juint val2) = 0; | |
| 103 | |
| 104 // Operations on arrays, or general regions (e.g., for "clone") may be | |
| 105 // optimized by some barriers. | |
| 106 | |
| 107 // The first six operations tell whether such an optimization exists for | |
| 108 // the particular barrier. | |
| 109 virtual bool has_read_ref_array_opt() = 0; | |
| 110 virtual bool has_read_prim_array_opt() = 0; | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
111 virtual bool has_write_ref_array_pre_opt() { return true; } |
| 0 | 112 virtual bool has_write_ref_array_opt() = 0; |
| 113 virtual bool has_write_prim_array_opt() = 0; | |
| 114 | |
| 115 virtual bool has_read_region_opt() = 0; | |
| 116 virtual bool has_write_region_opt() = 0; | |
| 117 | |
| 118 // These operations should assert false unless the correponding operation | |
| 119 // above returns true. Otherwise, they should perform an appropriate | |
| 120 // barrier for an array whose elements are all in the given memory region. | |
| 121 virtual void read_ref_array(MemRegion mr) = 0; | |
| 122 virtual void read_prim_array(MemRegion mr) = 0; | |
| 123 | |
|
1091
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
124 // Below length is the # array elements being written |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
125 virtual void write_ref_array_pre( oop* dst, int length) {} |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
356
diff
changeset
|
126 virtual void write_ref_array_pre(narrowOop* dst, int length) {} |
|
1091
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
127 // Below MemRegion mr is expected to be HeapWord-aligned |
| 0 | 128 inline void write_ref_array(MemRegion mr); |
|
1091
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
129 // Below count is the # array elements being written, starting |
|
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
130 // at the address "start", which may not necessarily be HeapWord-aligned |
|
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
131 inline void write_ref_array(HeapWord* start, size_t count); |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
132 |
|
1091
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
133 // Static versions, suitable for calling from generated code; |
|
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
134 // count is # array elements being written, starting with "start", |
|
6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
845
diff
changeset
|
135 // which may not necessarily be HeapWord-aligned. |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
136 static void static_write_ref_array_pre(HeapWord* start, size_t count); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
137 static void static_write_ref_array_post(HeapWord* start, size_t count); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
138 |
| 0 | 139 protected: |
| 140 virtual void write_ref_array_work(MemRegion mr) = 0; | |
| 141 public: | |
| 142 virtual void write_prim_array(MemRegion mr) = 0; | |
| 143 | |
| 144 virtual void read_region(MemRegion mr) = 0; | |
| 145 | |
| 146 // (For efficiency reasons, this operation is specialized for certain | |
| 147 // barrier types. Semantically, it should be thought of as a call to the | |
| 148 // virtual "_work" function below, which must implement the barrier.) | |
| 149 inline void write_region(MemRegion mr); | |
| 150 protected: | |
| 151 virtual void write_region_work(MemRegion mr) = 0; | |
| 152 public: | |
| 153 | |
| 154 // Some barrier sets create tables whose elements correspond to parts of | |
| 155 // the heap; the CardTableModRefBS is an example. Such barrier sets will | |
| 156 // normally reserve space for such tables, and commit parts of the table | |
| 157 // "covering" parts of the heap that are committed. The constructor is | |
| 158 // passed the maximum number of independently committable subregions to | |
| 159 // be covered, and the "resize_covoered_region" function allows the | |
| 160 // sub-parts of the heap to inform the barrier set of changes of their | |
| 161 // sizes. | |
| 162 BarrierSet(int max_covered_regions) : | |
| 163 _max_covered_regions(max_covered_regions) {} | |
| 164 | |
| 165 // Inform the BarrierSet that the the covered heap region that starts | |
| 166 // with "base" has been changed to have the given size (possibly from 0, | |
| 167 // for initialization.) | |
| 168 virtual void resize_covered_region(MemRegion new_region) = 0; | |
| 169 | |
| 170 // If the barrier set imposes any alignment restrictions on boundaries | |
| 171 // within the heap, this function tells whether they are met. | |
| 172 virtual bool is_aligned(HeapWord* addr) = 0; | |
| 173 | |
| 174 }; |