annotate src/share/vm/memory/barrierSet.hpp @ 452:00b023ae2d78

6722113: CMS: Incorrect overflow handling during precleaning of Reference lists Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery. Reviewed-by: apetrusenko, jcoomes
author ysr
date Thu, 20 Nov 2008 12:27:41 -0800
parents 1ee8caae33af
children df6caf649ff7
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
196
d1605aabd0a1 6719955: Update copyright year
xdono
parents: 113
diff changeset
2 * Copyright 2000-2008 Sun Microsystems, Inc. All Rights Reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 // This class provides the interface between a barrier implementation and
a61af66fc99e Initial load
duke
parents:
diff changeset
26 // the rest of the system.
a61af66fc99e Initial load
duke
parents:
diff changeset
27
a61af66fc99e Initial load
duke
parents:
diff changeset
28 class BarrierSet: public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
29 friend class VMStructs;
a61af66fc99e Initial load
duke
parents:
diff changeset
30 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
31 enum Name {
a61af66fc99e Initial load
duke
parents:
diff changeset
32 ModRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
33 CardTableModRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
37 Other,
a61af66fc99e Initial load
duke
parents:
diff changeset
38 Uninit
a61af66fc99e Initial load
duke
parents:
diff changeset
39 };
a61af66fc99e Initial load
duke
parents:
diff changeset
40
a61af66fc99e Initial load
duke
parents:
diff changeset
41 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
42 int _max_covered_regions;
a61af66fc99e Initial load
duke
parents:
diff changeset
43 Name _kind;
a61af66fc99e Initial load
duke
parents:
diff changeset
44
a61af66fc99e Initial load
duke
parents:
diff changeset
45 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
46
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
47 BarrierSet() { _kind = Uninit; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
50 virtual bool is_a(BarrierSet::Name bsn) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
51
a61af66fc99e Initial load
duke
parents:
diff changeset
52 // These operations indicate what kind of barriers the BarrierSet has.
a61af66fc99e Initial load
duke
parents:
diff changeset
53 virtual bool has_read_ref_barrier() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
54 virtual bool has_read_prim_barrier() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
57 virtual bool has_write_prim_barrier() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
58
a61af66fc99e Initial load
duke
parents:
diff changeset
59 // These functions indicate whether a particular access of the given
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
66
a61af66fc99e Initial load
duke
parents:
diff changeset
67 // The first four operations provide a direct implementation of the
a61af66fc99e Initial load
duke
parents:
diff changeset
68 // barrier set. An interpreter loop, for example, could call these
a61af66fc99e Initial load
duke
parents:
diff changeset
69 // directly, as appropriate.
a61af66fc99e Initial load
duke
parents:
diff changeset
70
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
73
a61af66fc99e Initial load
duke
parents:
diff changeset
74 // Invoke the barrier, if any, necessary when reading the given primitive
a61af66fc99e Initial load
duke
parents:
diff changeset
75 // "field" of "bytes" bytes in "obj".
a61af66fc99e Initial load
duke
parents:
diff changeset
76 virtual void read_prim_field(HeapWord* field, size_t bytes) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
77
a61af66fc99e Initial load
duke
parents:
diff changeset
78 // Invoke the barrier, if any, necessary when writing "new_val" into the
a61af66fc99e Initial load
duke
parents:
diff changeset
79 // ref field at "offset" in "obj".
a61af66fc99e Initial load
duke
parents:
diff changeset
80 // (For efficiency reasons, this operation is specialized for certain
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // barrier types. Semantically, it should be thought of as a call to the
a61af66fc99e Initial load
duke
parents:
diff changeset
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...
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
84 inline void write_ref_field_pre(void* field, oop new_val);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
85 protected:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
86 virtual void write_ref_field_pre_work(void* field, oop new_val) {};
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
87 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
88
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
89 // ...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
90 inline void write_ref_field(void* field, oop new_val);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
91 protected:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
92 virtual void write_ref_field_work(void* field, oop new_val) = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
93 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
94
a61af66fc99e Initial load
duke
parents:
diff changeset
95 // Invoke the barrier, if any, necessary when writing the "bytes"-byte
a61af66fc99e Initial load
duke
parents:
diff changeset
96 // value(s) "val1" (and "val2") into the primitive "field".
a61af66fc99e Initial load
duke
parents:
diff changeset
97 virtual void write_prim_field(HeapWord* field, size_t bytes,
a61af66fc99e Initial load
duke
parents:
diff changeset
98 juint val1, juint val2) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
99
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // Operations on arrays, or general regions (e.g., for "clone") may be
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // optimized by some barriers.
a61af66fc99e Initial load
duke
parents:
diff changeset
102
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // The first six operations tell whether such an optimization exists for
a61af66fc99e Initial load
duke
parents:
diff changeset
104 // the particular barrier.
a61af66fc99e Initial load
duke
parents:
diff changeset
105 virtual bool has_read_ref_array_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
106 virtual bool has_read_prim_array_opt() = 0;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
107 virtual bool has_write_ref_array_pre_opt() { return true; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
108 virtual bool has_write_ref_array_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
109 virtual bool has_write_prim_array_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
110
a61af66fc99e Initial load
duke
parents:
diff changeset
111 virtual bool has_read_region_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
112 virtual bool has_write_region_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
113
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // These operations should assert false unless the correponding operation
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // above returns true. Otherwise, they should perform an appropriate
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // barrier for an array whose elements are all in the given memory region.
a61af66fc99e Initial load
duke
parents:
diff changeset
117 virtual void read_ref_array(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
118 virtual void read_prim_array(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
119
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
120 virtual void write_ref_array_pre(MemRegion mr) {}
0
a61af66fc99e Initial load
duke
parents:
diff changeset
121 inline void write_ref_array(MemRegion mr);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
122
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
123 // Static versions, suitable for calling from generated code.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
124 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
125 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
126
0
a61af66fc99e Initial load
duke
parents:
diff changeset
127 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
128 virtual void write_ref_array_work(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
129 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
130 virtual void write_prim_array(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
131
a61af66fc99e Initial load
duke
parents:
diff changeset
132 virtual void read_region(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
133
a61af66fc99e Initial load
duke
parents:
diff changeset
134 // (For efficiency reasons, this operation is specialized for certain
a61af66fc99e Initial load
duke
parents:
diff changeset
135 // barrier types. Semantically, it should be thought of as a call to the
a61af66fc99e Initial load
duke
parents:
diff changeset
136 // virtual "_work" function below, which must implement the barrier.)
a61af66fc99e Initial load
duke
parents:
diff changeset
137 inline void write_region(MemRegion mr);
a61af66fc99e Initial load
duke
parents:
diff changeset
138 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
139 virtual void write_region_work(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
140 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
141
a61af66fc99e Initial load
duke
parents:
diff changeset
142 // Some barrier sets create tables whose elements correspond to parts of
a61af66fc99e Initial load
duke
parents:
diff changeset
143 // the heap; the CardTableModRefBS is an example. Such barrier sets will
a61af66fc99e Initial load
duke
parents:
diff changeset
144 // normally reserve space for such tables, and commit parts of the table
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // "covering" parts of the heap that are committed. The constructor is
a61af66fc99e Initial load
duke
parents:
diff changeset
146 // passed the maximum number of independently committable subregions to
a61af66fc99e Initial load
duke
parents:
diff changeset
147 // be covered, and the "resize_covoered_region" function allows the
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // sub-parts of the heap to inform the barrier set of changes of their
a61af66fc99e Initial load
duke
parents:
diff changeset
149 // sizes.
a61af66fc99e Initial load
duke
parents:
diff changeset
150 BarrierSet(int max_covered_regions) :
a61af66fc99e Initial load
duke
parents:
diff changeset
151 _max_covered_regions(max_covered_regions) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
152
a61af66fc99e Initial load
duke
parents:
diff changeset
153 // Inform the BarrierSet that the the covered heap region that starts
a61af66fc99e Initial load
duke
parents:
diff changeset
154 // with "base" has been changed to have the given size (possibly from 0,
a61af66fc99e Initial load
duke
parents:
diff changeset
155 // for initialization.)
a61af66fc99e Initial load
duke
parents:
diff changeset
156 virtual void resize_covered_region(MemRegion new_region) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 // If the barrier set imposes any alignment restrictions on boundaries
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // within the heap, this function tells whether they are met.
a61af66fc99e Initial load
duke
parents:
diff changeset
160 virtual bool is_aligned(HeapWord* addr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 };