Mercurial > hg > graal-compiler
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 |
rev | line source |
---|---|
0 | 1 /* |
196 | 2 * Copyright 2000-2008 Sun Microsystems, Inc. All Rights Reserved. |
0 | 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, | |
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 | 37 Other, |
38 Uninit | |
39 }; | |
40 | |
41 protected: | |
42 int _max_covered_regions; | |
43 Name _kind; | |
44 | |
45 public: | |
46 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
47 BarrierSet() { _kind = Uninit; } |
0 | 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 | 50 virtual bool is_a(BarrierSet::Name bsn) = 0; |
51 | |
52 // These operations indicate what kind of barriers the BarrierSet has. | |
53 virtual bool has_read_ref_barrier() = 0; | |
54 virtual bool has_read_prim_barrier() = 0; | |
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 | 57 virtual bool has_write_prim_barrier() = 0; |
58 | |
59 // These functions indicate whether a particular access of the given | |
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 | 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 | 66 |
67 // The first four operations provide a direct implementation of the | |
68 // barrier set. An interpreter loop, for example, could call these | |
69 // directly, as appropriate. | |
70 | |
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 | 73 |
74 // Invoke the barrier, if any, necessary when reading the given primitive | |
75 // "field" of "bytes" bytes in "obj". | |
76 virtual void read_prim_field(HeapWord* field, size_t bytes) = 0; | |
77 | |
78 // Invoke the barrier, if any, necessary when writing "new_val" into the | |
79 // ref field at "offset" in "obj". | |
80 // (For efficiency reasons, this operation is specialized for certain | |
81 // barrier types. Semantically, it should be thought of as a call to the | |
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 | 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 | 93 public: |
94 | |
95 // Invoke the barrier, if any, necessary when writing the "bytes"-byte | |
96 // value(s) "val1" (and "val2") into the primitive "field". | |
97 virtual void write_prim_field(HeapWord* field, size_t bytes, | |
98 juint val1, juint val2) = 0; | |
99 | |
100 // Operations on arrays, or general regions (e.g., for "clone") may be | |
101 // optimized by some barriers. | |
102 | |
103 // The first six operations tell whether such an optimization exists for | |
104 // the particular barrier. | |
105 virtual bool has_read_ref_array_opt() = 0; | |
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 | 108 virtual bool has_write_ref_array_opt() = 0; |
109 virtual bool has_write_prim_array_opt() = 0; | |
110 | |
111 virtual bool has_read_region_opt() = 0; | |
112 virtual bool has_write_region_opt() = 0; | |
113 | |
114 // These operations should assert false unless the correponding operation | |
115 // above returns true. Otherwise, they should perform an appropriate | |
116 // barrier for an array whose elements are all in the given memory region. | |
117 virtual void read_ref_array(MemRegion mr) = 0; | |
118 virtual void read_prim_array(MemRegion mr) = 0; | |
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 | 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 | 127 protected: |
128 virtual void write_ref_array_work(MemRegion mr) = 0; | |
129 public: | |
130 virtual void write_prim_array(MemRegion mr) = 0; | |
131 | |
132 virtual void read_region(MemRegion mr) = 0; | |
133 | |
134 // (For efficiency reasons, this operation is specialized for certain | |
135 // barrier types. Semantically, it should be thought of as a call to the | |
136 // virtual "_work" function below, which must implement the barrier.) | |
137 inline void write_region(MemRegion mr); | |
138 protected: | |
139 virtual void write_region_work(MemRegion mr) = 0; | |
140 public: | |
141 | |
142 // Some barrier sets create tables whose elements correspond to parts of | |
143 // the heap; the CardTableModRefBS is an example. Such barrier sets will | |
144 // normally reserve space for such tables, and commit parts of the table | |
145 // "covering" parts of the heap that are committed. The constructor is | |
146 // passed the maximum number of independently committable subregions to | |
147 // be covered, and the "resize_covoered_region" function allows the | |
148 // sub-parts of the heap to inform the barrier set of changes of their | |
149 // sizes. | |
150 BarrierSet(int max_covered_regions) : | |
151 _max_covered_regions(max_covered_regions) {} | |
152 | |
153 // Inform the BarrierSet that the the covered heap region that starts | |
154 // with "base" has been changed to have the given size (possibly from 0, | |
155 // for initialization.) | |
156 virtual void resize_covered_region(MemRegion new_region) = 0; | |
157 | |
158 // If the barrier set imposes any alignment restrictions on boundaries | |
159 // within the heap, this function tells whether they are met. | |
160 virtual bool is_aligned(HeapWord* addr) = 0; | |
161 | |
162 }; |