annotate src/share/vm/memory/barrierSet.hpp @ 1994:6cd6d394f280

7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed()) 7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages. Reviewed-by: johnc, tonyp
author ysr
date Tue, 07 Dec 2010 21:55:53 -0800
parents f95d63e2154a
children 0ac769a57c64
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. 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 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1245
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1245
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1245
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
25 #ifndef SHARE_VM_MEMORY_BARRIERSET_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #define SHARE_VM_MEMORY_BARRIERSET_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "memory/memRegion.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
29 #include "oops/oopsHierarchy.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
30
0
a61af66fc99e Initial load
duke
parents:
diff changeset
31 // This class provides the interface between a barrier implementation and
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // the rest of the system.
a61af66fc99e Initial load
duke
parents:
diff changeset
33
a61af66fc99e Initial load
duke
parents:
diff changeset
34 class BarrierSet: public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
35 friend class VMStructs;
a61af66fc99e Initial load
duke
parents:
diff changeset
36 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
37 enum Name {
a61af66fc99e Initial load
duke
parents:
diff changeset
38 ModRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
39 CardTableModRef,
a61af66fc99e Initial load
duke
parents:
diff changeset
40 CardTableExtension,
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
41 G1SATBCT,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
42 G1SATBCTLogging,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
43 Other,
a61af66fc99e Initial load
duke
parents:
diff changeset
44 Uninit
a61af66fc99e Initial load
duke
parents:
diff changeset
45 };
a61af66fc99e Initial load
duke
parents:
diff changeset
46
a61af66fc99e Initial load
duke
parents:
diff changeset
47 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
48 int _max_covered_regions;
a61af66fc99e Initial load
duke
parents:
diff changeset
49 Name _kind;
a61af66fc99e Initial load
duke
parents:
diff changeset
50
a61af66fc99e Initial load
duke
parents:
diff changeset
51 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
52
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
53 BarrierSet() { _kind = Uninit; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
54 // To get around prohibition on RTTI.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
55 BarrierSet::Name kind() { return _kind; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
56 virtual bool is_a(BarrierSet::Name bsn) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
57
a61af66fc99e Initial load
duke
parents:
diff changeset
58 // These operations indicate what kind of barriers the BarrierSet has.
a61af66fc99e Initial load
duke
parents:
diff changeset
59 virtual bool has_read_ref_barrier() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
60 virtual bool has_read_prim_barrier() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
61 virtual bool has_write_ref_barrier() = 0;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
62 virtual bool has_write_ref_pre_barrier() = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
63 virtual bool has_write_prim_barrier() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
64
a61af66fc99e Initial load
duke
parents:
diff changeset
65 // These functions indicate whether a particular access of the given
a61af66fc99e Initial load
duke
parents:
diff changeset
66 // kinds requires a barrier.
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
67 virtual bool read_ref_needs_barrier(void* field) = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
68 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
69 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
70 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
71 juint val1, juint val2) = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 // The first four operations provide a direct implementation of the
a61af66fc99e Initial load
duke
parents:
diff changeset
74 // barrier set. An interpreter loop, for example, could call these
a61af66fc99e Initial load
duke
parents:
diff changeset
75 // directly, as appropriate.
a61af66fc99e Initial load
duke
parents:
diff changeset
76
a61af66fc99e Initial load
duke
parents:
diff changeset
77 // 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
78 virtual void read_ref_field(void* field) = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 // Invoke the barrier, if any, necessary when reading the given primitive
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // "field" of "bytes" bytes in "obj".
a61af66fc99e Initial load
duke
parents:
diff changeset
82 virtual void read_prim_field(HeapWord* field, size_t bytes) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
83
a61af66fc99e Initial load
duke
parents:
diff changeset
84 // Invoke the barrier, if any, necessary when writing "new_val" into the
a61af66fc99e Initial load
duke
parents:
diff changeset
85 // ref field at "offset" in "obj".
a61af66fc99e Initial load
duke
parents:
diff changeset
86 // (For efficiency reasons, this operation is specialized for certain
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // barrier types. Semantically, it should be thought of as a call to the
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // virtual "_work" function below, which must implement the barrier.)
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
89 // First the pre-write versions...
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
90 template <class T> inline void write_ref_field_pre(T* field, oop new_val);
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
91 private:
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
92 // Keep this private so as to catch violations at build time.
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
93 virtual void write_ref_field_pre_work( void* field, oop new_val) { guarantee(false, "Not needed"); };
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
94 protected:
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
95 virtual void write_ref_field_pre_work( oop* field, oop new_val) {};
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
96 virtual void write_ref_field_pre_work(narrowOop* field, oop new_val) {};
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
97 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
98
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
99 // ...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
100 inline void write_ref_field(void* field, oop new_val);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
101 protected:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
102 virtual void write_ref_field_work(void* field, oop new_val) = 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
103 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
104
a61af66fc99e Initial load
duke
parents:
diff changeset
105 // Invoke the barrier, if any, necessary when writing the "bytes"-byte
a61af66fc99e Initial load
duke
parents:
diff changeset
106 // value(s) "val1" (and "val2") into the primitive "field".
a61af66fc99e Initial load
duke
parents:
diff changeset
107 virtual void write_prim_field(HeapWord* field, size_t bytes,
a61af66fc99e Initial load
duke
parents:
diff changeset
108 juint val1, juint val2) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
109
a61af66fc99e Initial load
duke
parents:
diff changeset
110 // Operations on arrays, or general regions (e.g., for "clone") may be
a61af66fc99e Initial load
duke
parents:
diff changeset
111 // optimized by some barriers.
a61af66fc99e Initial load
duke
parents:
diff changeset
112
a61af66fc99e Initial load
duke
parents:
diff changeset
113 // The first six operations tell whether such an optimization exists for
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // the particular barrier.
a61af66fc99e Initial load
duke
parents:
diff changeset
115 virtual bool has_read_ref_array_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
116 virtual bool has_read_prim_array_opt() = 0;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
117 virtual bool has_write_ref_array_pre_opt() { return true; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
118 virtual bool has_write_ref_array_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
119 virtual bool has_write_prim_array_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
120
a61af66fc99e Initial load
duke
parents:
diff changeset
121 virtual bool has_read_region_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
122 virtual bool has_write_region_opt() = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
123
a61af66fc99e Initial load
duke
parents:
diff changeset
124 // These operations should assert false unless the correponding operation
a61af66fc99e Initial load
duke
parents:
diff changeset
125 // above returns true. Otherwise, they should perform an appropriate
a61af66fc99e Initial load
duke
parents:
diff changeset
126 // barrier for an array whose elements are all in the given memory region.
a61af66fc99e Initial load
duke
parents:
diff changeset
127 virtual void read_ref_array(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
128 virtual void read_prim_array(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
129
1091
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
130 // Below length is the # array elements being written
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
131 virtual void write_ref_array_pre( oop* dst, int length) {}
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 356
diff changeset
132 virtual void write_ref_array_pre(narrowOop* dst, int length) {}
1091
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
133 // Below count is the # array elements being written, starting
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
134 // at the address "start", which may not necessarily be HeapWord-aligned
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
135 inline void write_ref_array(HeapWord* start, size_t count);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
136
1091
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
137 // Static versions, suitable for calling from generated code;
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
138 // count is # array elements being written, starting with "start",
6aa7255741f3 6906727: UseCompressedOops: some card-marking fixes related to object arrays
ysr
parents: 845
diff changeset
139 // which may not necessarily be HeapWord-aligned.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 113
diff changeset
140 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
141 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
142
0
a61af66fc99e Initial load
duke
parents:
diff changeset
143 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
144 virtual void write_ref_array_work(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
145 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
146 virtual void write_prim_array(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
147
a61af66fc99e Initial load
duke
parents:
diff changeset
148 virtual void read_region(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
149
a61af66fc99e Initial load
duke
parents:
diff changeset
150 // (For efficiency reasons, this operation is specialized for certain
a61af66fc99e Initial load
duke
parents:
diff changeset
151 // barrier types. Semantically, it should be thought of as a call to the
a61af66fc99e Initial load
duke
parents:
diff changeset
152 // virtual "_work" function below, which must implement the barrier.)
a61af66fc99e Initial load
duke
parents:
diff changeset
153 inline void write_region(MemRegion mr);
a61af66fc99e Initial load
duke
parents:
diff changeset
154 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
155 virtual void write_region_work(MemRegion mr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
156 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
157
a61af66fc99e Initial load
duke
parents:
diff changeset
158 // Some barrier sets create tables whose elements correspond to parts of
a61af66fc99e Initial load
duke
parents:
diff changeset
159 // the heap; the CardTableModRefBS is an example. Such barrier sets will
a61af66fc99e Initial load
duke
parents:
diff changeset
160 // normally reserve space for such tables, and commit parts of the table
a61af66fc99e Initial load
duke
parents:
diff changeset
161 // "covering" parts of the heap that are committed. The constructor is
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // passed the maximum number of independently committable subregions to
a61af66fc99e Initial load
duke
parents:
diff changeset
163 // be covered, and the "resize_covoered_region" function allows the
a61af66fc99e Initial load
duke
parents:
diff changeset
164 // sub-parts of the heap to inform the barrier set of changes of their
a61af66fc99e Initial load
duke
parents:
diff changeset
165 // sizes.
a61af66fc99e Initial load
duke
parents:
diff changeset
166 BarrierSet(int max_covered_regions) :
a61af66fc99e Initial load
duke
parents:
diff changeset
167 _max_covered_regions(max_covered_regions) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
168
a61af66fc99e Initial load
duke
parents:
diff changeset
169 // Inform the BarrierSet that the the covered heap region that starts
a61af66fc99e Initial load
duke
parents:
diff changeset
170 // with "base" has been changed to have the given size (possibly from 0,
a61af66fc99e Initial load
duke
parents:
diff changeset
171 // for initialization.)
a61af66fc99e Initial load
duke
parents:
diff changeset
172 virtual void resize_covered_region(MemRegion new_region) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
173
a61af66fc99e Initial load
duke
parents:
diff changeset
174 // If the barrier set imposes any alignment restrictions on boundaries
a61af66fc99e Initial load
duke
parents:
diff changeset
175 // within the heap, this function tells whether they are met.
a61af66fc99e Initial load
duke
parents:
diff changeset
176 virtual bool is_aligned(HeapWord* addr) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
177
a61af66fc99e Initial load
duke
parents:
diff changeset
178 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
179
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
180 #endif // SHARE_VM_MEMORY_BARRIERSET_HPP