0
|
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 };
|