Mercurial > hg > graal-jvmci-8
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 |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. 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 * | |
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 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_MEMORY_BARRIERSET_HPP |
26 #define SHARE_VM_MEMORY_BARRIERSET_HPP | |
27 | |
28 #include "memory/memRegion.hpp" | |
29 #include "oops/oopsHierarchy.hpp" | |
30 | |
0 | 31 // This class provides the interface between a barrier implementation and |
32 // the rest of the system. | |
33 | |
34 class BarrierSet: public CHeapObj { | |
35 friend class VMStructs; | |
36 public: | |
37 enum Name { | |
38 ModRef, | |
39 CardTableModRef, | |
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 | 43 Other, |
44 Uninit | |
45 }; | |
46 | |
47 protected: | |
48 int _max_covered_regions; | |
49 Name _kind; | |
50 | |
51 public: | |
52 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
53 BarrierSet() { _kind = Uninit; } |
0 | 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 | 56 virtual bool is_a(BarrierSet::Name bsn) = 0; |
57 | |
58 // These operations indicate what kind of barriers the BarrierSet has. | |
59 virtual bool has_read_ref_barrier() = 0; | |
60 virtual bool has_read_prim_barrier() = 0; | |
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 | 63 virtual bool has_write_prim_barrier() = 0; |
64 | |
65 // These functions indicate whether a particular access of the given | |
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 | 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 | 72 |
73 // The first four operations provide a direct implementation of the | |
74 // barrier set. An interpreter loop, for example, could call these | |
75 // directly, as appropriate. | |
76 | |
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 | 79 |
80 // Invoke the barrier, if any, necessary when reading the given primitive | |
81 // "field" of "bytes" bytes in "obj". | |
82 virtual void read_prim_field(HeapWord* field, size_t bytes) = 0; | |
83 | |
84 // Invoke the barrier, if any, necessary when writing "new_val" into the | |
85 // ref field at "offset" in "obj". | |
86 // (For efficiency reasons, this operation is specialized for certain | |
87 // barrier types. Semantically, it should be thought of as a call to the | |
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 | 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 | 103 public: |
104 | |
105 // Invoke the barrier, if any, necessary when writing the "bytes"-byte | |
106 // value(s) "val1" (and "val2") into the primitive "field". | |
107 virtual void write_prim_field(HeapWord* field, size_t bytes, | |
108 juint val1, juint val2) = 0; | |
109 | |
110 // Operations on arrays, or general regions (e.g., for "clone") may be | |
111 // optimized by some barriers. | |
112 | |
113 // The first six operations tell whether such an optimization exists for | |
114 // the particular barrier. | |
115 virtual bool has_read_ref_array_opt() = 0; | |
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 | 118 virtual bool has_write_ref_array_opt() = 0; |
119 virtual bool has_write_prim_array_opt() = 0; | |
120 | |
121 virtual bool has_read_region_opt() = 0; | |
122 virtual bool has_write_region_opt() = 0; | |
123 | |
124 // These operations should assert false unless the correponding operation | |
125 // above returns true. Otherwise, they should perform an appropriate | |
126 // barrier for an array whose elements are all in the given memory region. | |
127 virtual void read_ref_array(MemRegion mr) = 0; | |
128 virtual void read_prim_array(MemRegion mr) = 0; | |
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 | 143 protected: |
144 virtual void write_ref_array_work(MemRegion mr) = 0; | |
145 public: | |
146 virtual void write_prim_array(MemRegion mr) = 0; | |
147 | |
148 virtual void read_region(MemRegion mr) = 0; | |
149 | |
150 // (For efficiency reasons, this operation is specialized for certain | |
151 // barrier types. Semantically, it should be thought of as a call to the | |
152 // virtual "_work" function below, which must implement the barrier.) | |
153 inline void write_region(MemRegion mr); | |
154 protected: | |
155 virtual void write_region_work(MemRegion mr) = 0; | |
156 public: | |
157 | |
158 // Some barrier sets create tables whose elements correspond to parts of | |
159 // the heap; the CardTableModRefBS is an example. Such barrier sets will | |
160 // normally reserve space for such tables, and commit parts of the table | |
161 // "covering" parts of the heap that are committed. The constructor is | |
162 // passed the maximum number of independently committable subregions to | |
163 // be covered, and the "resize_covoered_region" function allows the | |
164 // sub-parts of the heap to inform the barrier set of changes of their | |
165 // sizes. | |
166 BarrierSet(int max_covered_regions) : | |
167 _max_covered_regions(max_covered_regions) {} | |
168 | |
169 // Inform the BarrierSet that the the covered heap region that starts | |
170 // with "base" has been changed to have the given size (possibly from 0, | |
171 // for initialization.) | |
172 virtual void resize_covered_region(MemRegion new_region) = 0; | |
173 | |
174 // If the barrier set imposes any alignment restrictions on boundaries | |
175 // within the heap, this function tells whether they are met. | |
176 virtual bool is_aligned(HeapWord* addr) = 0; | |
177 | |
178 }; | |
1972 | 179 |
180 #endif // SHARE_VM_MEMORY_BARRIERSET_HPP |