Mercurial > hg > graal-compiler

comparison src/share/vm/memory/barrierSet.hpp @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children ba764ed4b6f2
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
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 };