author | brutisso |
Mon, 21 Nov 2011 07:47:34 +0100 | |
changeset 11170 | 7663e46f3a54 |
parent 8498 | 6398004126b9 |
child 12268 | f7897aacb9ce |
permissions | -rw-r--r-- |
1 | 1 |
/* |
8498 | 2 |
* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4886
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4886
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4886
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#ifndef SHARE_VM_MEMORY_BARRIERSET_HPP |
26 |
#define SHARE_VM_MEMORY_BARRIERSET_HPP |
|
27 |
||
28 |
#include "memory/memRegion.hpp" |
|
29 |
#include "oops/oopsHierarchy.hpp" |
|
30 |
||
1 | 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, |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
41 |
G1SATBCT, |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
42 |
G1SATBCTLogging, |
1 | 43 |
Other, |
44 |
Uninit |
|
45 |
}; |
|
46 |
||
8498 | 47 |
enum Flags { |
48 |
None = 0, |
|
49 |
TargetUninitialized = 1 |
|
50 |
}; |
|
1 | 51 |
protected: |
52 |
int _max_covered_regions; |
|
53 |
Name _kind; |
|
54 |
||
55 |
public: |
|
56 |
||
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
57 |
BarrierSet() { _kind = Uninit; } |
1 | 58 |
// To get around prohibition on RTTI. |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
59 |
BarrierSet::Name kind() { return _kind; } |
1 | 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; |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
66 |
virtual bool has_write_ref_pre_barrier() = 0; |
1 | 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. |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
71 |
virtual bool read_ref_needs_barrier(void* field) = 0; |
1 | 72 |
virtual bool read_prim_needs_barrier(HeapWord* field, size_t bytes) = 0; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
73 |
virtual bool write_ref_needs_barrier(void* field, oop new_val) = 0; |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
74 |
virtual bool write_prim_needs_barrier(HeapWord* field, size_t bytes, |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
75 |
juint val1, juint val2) = 0; |
1 | 76 |
|
77 |
// The first four operations provide a direct implementation of the |
|
78 |
// barrier set. An interpreter loop, for example, could call these |
|
79 |
// directly, as appropriate. |
|
80 |
||
81 |
// Invoke the barrier, if any, necessary when reading the given ref field. |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
82 |
virtual void read_ref_field(void* field) = 0; |
1 | 83 |
|
84 |
// Invoke the barrier, if any, necessary when reading the given primitive |
|
85 |
// "field" of "bytes" bytes in "obj". |
|
86 |
virtual void read_prim_field(HeapWord* field, size_t bytes) = 0; |
|
87 |
||
88 |
// Invoke the barrier, if any, necessary when writing "new_val" into the |
|
89 |
// ref field at "offset" in "obj". |
|
90 |
// (For efficiency reasons, this operation is specialized for certain |
|
91 |
// barrier types. Semantically, it should be thought of as a call to the |
|
92 |
// virtual "_work" function below, which must implement the barrier.) |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
93 |
// First the pre-write versions... |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1388
diff
changeset
|
94 |
template <class T> inline void write_ref_field_pre(T* field, oop new_val); |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1388
diff
changeset
|
95 |
private: |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1388
diff
changeset
|
96 |
// Keep this private so as to catch violations at build time. |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1388
diff
changeset
|
97 |
virtual void write_ref_field_pre_work( void* field, oop new_val) { guarantee(false, "Not needed"); }; |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
98 |
protected: |
3262
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1388
diff
changeset
|
99 |
virtual void write_ref_field_pre_work( oop* field, oop new_val) {}; |
30d1c247fc25
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
1388
diff
changeset
|
100 |
virtual void write_ref_field_pre_work(narrowOop* field, oop new_val) {}; |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
101 |
public: |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
102 |
|
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
103 |
// ...then the post-write version. |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
104 |
inline void write_ref_field(void* field, oop new_val); |
1 | 105 |
protected: |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
106 |
virtual void write_ref_field_work(void* field, oop new_val) = 0; |
1 | 107 |
public: |
108 |
||
109 |
// Invoke the barrier, if any, necessary when writing the "bytes"-byte |
|
110 |
// value(s) "val1" (and "val2") into the primitive "field". |
|
111 |
virtual void write_prim_field(HeapWord* field, size_t bytes, |
|
112 |
juint val1, juint val2) = 0; |
|
113 |
||
114 |
// Operations on arrays, or general regions (e.g., for "clone") may be |
|
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; |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
121 |
virtual bool has_write_ref_array_pre_opt() { return true; } |
1 | 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 |
||
4461
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
134 |
// Below length is the # array elements being written |
8498 | 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) {} |
|
4461
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
139 |
// Below count is the # array elements being written, starting |
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
140 |
// at the address "start", which may not necessarily be HeapWord-aligned |
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
141 |
inline void write_ref_array(HeapWord* start, size_t count); |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
142 |
|
4461
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
143 |
// Static versions, suitable for calling from generated code; |
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
144 |
// count is # array elements being written, starting with "start", |
c17c526d36ef
6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents:
3262
diff
changeset
|
145 |
// which may not necessarily be HeapWord-aligned. |
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
146 |
static void static_write_ref_array_pre(HeapWord* start, size_t count); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
147 |
static void static_write_ref_array_post(HeapWord* start, size_t count); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
360
diff
changeset
|
148 |
|
1 | 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.) |
|
159 |
inline void write_region(MemRegion mr); |
|
160 |
protected: |
|
161 |
virtual void write_region_work(MemRegion mr) = 0; |
|
162 |
public: |
|
163 |
||
164 |
// Some barrier sets create tables whose elements correspond to parts of |
|
165 |
// the heap; the CardTableModRefBS is an example. Such barrier sets will |
|
166 |
// normally reserve space for such tables, and commit parts of the table |
|
167 |
// "covering" parts of the heap that are committed. The constructor is |
|
168 |
// passed the maximum number of independently committable subregions to |
|
169 |
// be covered, and the "resize_covoered_region" function allows the |
|
170 |
// sub-parts of the heap to inform the barrier set of changes of their |
|
171 |
// sizes. |
|
172 |
BarrierSet(int max_covered_regions) : |
|
173 |
_max_covered_regions(max_covered_regions) {} |
|
174 |
||
175 |
// Inform the BarrierSet that the the covered heap region that starts |
|
176 |
// with "base" has been changed to have the given size (possibly from 0, |
|
177 |
// for initialization.) |
|
178 |
virtual void resize_covered_region(MemRegion new_region) = 0; |
|
179 |
||
180 |
// If the barrier set imposes any alignment restrictions on boundaries |
|
181 |
// within the heap, this function tells whether they are met. |
|
182 |
virtual bool is_aligned(HeapWord* addr) = 0; |
|
183 |
||
184 |
}; |
|
7397 | 185 |
|
186 |
#endif // SHARE_VM_MEMORY_BARRIERSET_HPP |