1
|
1 |
/*
|
|
2 |
* Copyright 2000-2002 Sun Microsystems, Inc. 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 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,
|
|
35 |
Other,
|
|
36 |
Uninit
|
|
37 |
};
|
|
38 |
|
|
39 |
protected:
|
|
40 |
int _max_covered_regions;
|
|
41 |
Name _kind;
|
|
42 |
|
|
43 |
public:
|
|
44 |
|
|
45 |
// To get around prohibition on RTTI.
|
|
46 |
virtual BarrierSet::Name kind() { return _kind; }
|
|
47 |
virtual bool is_a(BarrierSet::Name bsn) = 0;
|
|
48 |
|
|
49 |
// These operations indicate what kind of barriers the BarrierSet has.
|
|
50 |
virtual bool has_read_ref_barrier() = 0;
|
|
51 |
virtual bool has_read_prim_barrier() = 0;
|
|
52 |
virtual bool has_write_ref_barrier() = 0;
|
|
53 |
virtual bool has_write_prim_barrier() = 0;
|
|
54 |
|
|
55 |
// These functions indicate whether a particular access of the given
|
|
56 |
// kinds requires a barrier.
|
|
57 |
virtual bool read_ref_needs_barrier(oop* field) = 0;
|
|
58 |
virtual bool read_prim_needs_barrier(HeapWord* field, size_t bytes) = 0;
|
|
59 |
virtual bool write_ref_needs_barrier(oop* field, oop new_val) = 0;
|
|
60 |
virtual bool write_prim_needs_barrier(HeapWord* field, size_t bytes, juint val1, juint val2) = 0;
|
|
61 |
|
|
62 |
// The first four operations provide a direct implementation of the
|
|
63 |
// barrier set. An interpreter loop, for example, could call these
|
|
64 |
// directly, as appropriate.
|
|
65 |
|
|
66 |
// Invoke the barrier, if any, necessary when reading the given ref field.
|
|
67 |
virtual void read_ref_field(oop* field) = 0;
|
|
68 |
|
|
69 |
// Invoke the barrier, if any, necessary when reading the given primitive
|
|
70 |
// "field" of "bytes" bytes in "obj".
|
|
71 |
virtual void read_prim_field(HeapWord* field, size_t bytes) = 0;
|
|
72 |
|
|
73 |
// Invoke the barrier, if any, necessary when writing "new_val" into the
|
|
74 |
// ref field at "offset" in "obj".
|
|
75 |
// (For efficiency reasons, this operation is specialized for certain
|
|
76 |
// barrier types. Semantically, it should be thought of as a call to the
|
|
77 |
// virtual "_work" function below, which must implement the barrier.)
|
|
78 |
inline void write_ref_field(oop* field, oop new_val);
|
|
79 |
protected:
|
|
80 |
virtual void write_ref_field_work(oop* field, oop new_val) = 0;
|
|
81 |
public:
|
|
82 |
|
|
83 |
// Invoke the barrier, if any, necessary when writing the "bytes"-byte
|
|
84 |
// value(s) "val1" (and "val2") into the primitive "field".
|
|
85 |
virtual void write_prim_field(HeapWord* field, size_t bytes,
|
|
86 |
juint val1, juint val2) = 0;
|
|
87 |
|
|
88 |
// Operations on arrays, or general regions (e.g., for "clone") may be
|
|
89 |
// optimized by some barriers.
|
|
90 |
|
|
91 |
// The first six operations tell whether such an optimization exists for
|
|
92 |
// the particular barrier.
|
|
93 |
virtual bool has_read_ref_array_opt() = 0;
|
|
94 |
virtual bool has_read_prim_array_opt() = 0;
|
|
95 |
virtual bool has_write_ref_array_opt() = 0;
|
|
96 |
virtual bool has_write_prim_array_opt() = 0;
|
|
97 |
|
|
98 |
virtual bool has_read_region_opt() = 0;
|
|
99 |
virtual bool has_write_region_opt() = 0;
|
|
100 |
|
|
101 |
// These operations should assert false unless the correponding operation
|
|
102 |
// above returns true. Otherwise, they should perform an appropriate
|
|
103 |
// barrier for an array whose elements are all in the given memory region.
|
|
104 |
virtual void read_ref_array(MemRegion mr) = 0;
|
|
105 |
virtual void read_prim_array(MemRegion mr) = 0;
|
|
106 |
|
|
107 |
inline void write_ref_array(MemRegion mr);
|
|
108 |
protected:
|
|
109 |
virtual void write_ref_array_work(MemRegion mr) = 0;
|
|
110 |
public:
|
|
111 |
virtual void write_prim_array(MemRegion mr) = 0;
|
|
112 |
|
|
113 |
virtual void read_region(MemRegion mr) = 0;
|
|
114 |
|
|
115 |
// (For efficiency reasons, this operation is specialized for certain
|
|
116 |
// barrier types. Semantically, it should be thought of as a call to the
|
|
117 |
// virtual "_work" function below, which must implement the barrier.)
|
|
118 |
inline void write_region(MemRegion mr);
|
|
119 |
protected:
|
|
120 |
virtual void write_region_work(MemRegion mr) = 0;
|
|
121 |
public:
|
|
122 |
|
|
123 |
// The remaining sets of operations are called by compilers or other code
|
|
124 |
// generators to insert barriers into generated code. There may be
|
|
125 |
// several such code generators; the signatures of these
|
|
126 |
// barrier-generating functions may differ from generator to generator.
|
|
127 |
// There will be a set of four function signatures for each code
|
|
128 |
// generator, which accomplish the generation of barriers of the four
|
|
129 |
// kinds listed above.
|
|
130 |
|
|
131 |
#ifdef TBD
|
|
132 |
// Generates code to invoke the barrier, if any, necessary when reading
|
|
133 |
// the ref field at "offset" in "obj".
|
|
134 |
virtual void gen_read_ref_field() = 0;
|
|
135 |
|
|
136 |
// Generates code to invoke the barrier, if any, necessary when reading
|
|
137 |
// the primitive field of "bytes" bytes at offset" in "obj".
|
|
138 |
virtual void gen_read_prim_field() = 0;
|
|
139 |
|
|
140 |
// Generates code to invoke the barrier, if any, necessary when writing
|
|
141 |
// "new_val" into the ref field at "offset" in "obj".
|
|
142 |
virtual void gen_write_ref_field() = 0;
|
|
143 |
|
|
144 |
// Generates code to invoke the barrier, if any, necessary when writing
|
|
145 |
// the "bytes"-byte value "new_val" into the primitive field at "offset"
|
|
146 |
// in "obj".
|
|
147 |
virtual void gen_write_prim_field() = 0;
|
|
148 |
#endif
|
|
149 |
|
|
150 |
// Some barrier sets create tables whose elements correspond to parts of
|
|
151 |
// the heap; the CardTableModRefBS is an example. Such barrier sets will
|
|
152 |
// normally reserve space for such tables, and commit parts of the table
|
|
153 |
// "covering" parts of the heap that are committed. The constructor is
|
|
154 |
// passed the maximum number of independently committable subregions to
|
|
155 |
// be covered, and the "resize_covoered_region" function allows the
|
|
156 |
// sub-parts of the heap to inform the barrier set of changes of their
|
|
157 |
// sizes.
|
|
158 |
BarrierSet(int max_covered_regions) :
|
|
159 |
_max_covered_regions(max_covered_regions) {}
|
|
160 |
|
|
161 |
// Inform the BarrierSet that the the covered heap region that starts
|
|
162 |
// with "base" has been changed to have the given size (possibly from 0,
|
|
163 |
// for initialization.)
|
|
164 |
virtual void resize_covered_region(MemRegion new_region) = 0;
|
|
165 |
|
|
166 |
// If the barrier set imposes any alignment restrictions on boundaries
|
|
167 |
// within the heap, this function tells whether they are met.
|
|
168 |
virtual bool is_aligned(HeapWord* addr) = 0;
|
|
169 |
|
|
170 |
};
|