Mercurial > hg > truffle
annotate src/share/vm/oops/klassKlass.cpp @ 3762:5c0a3c1858b1
7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359
Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675.
Reviewed-by: brutisso
author | ysr |
---|---|
date | Thu, 02 Jun 2011 10:23:36 -0700 |
parents | c7f3d0b4570f |
children | 0654ee04b214 |
rev | line source |
---|---|
0 | 1 /* |
2227 | 2 * Copyright (c) 1997, 2011, 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:
1155
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1155
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:
1155
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "gc_implementation/shared/markSweep.inline.hpp" | |
27 #include "gc_interface/collectedHeap.hpp" | |
28 #include "gc_interface/collectedHeap.inline.hpp" | |
29 #include "memory/oopFactory.hpp" | |
30 #include "memory/permGen.hpp" | |
31 #include "oops/constantPoolKlass.hpp" | |
32 #include "oops/instanceKlass.hpp" | |
33 #include "oops/instanceOop.hpp" | |
34 #include "oops/klassKlass.hpp" | |
35 #include "oops/klassOop.hpp" | |
36 #include "oops/methodKlass.hpp" | |
37 #include "oops/objArrayKlass.hpp" | |
38 #include "oops/oop.inline.hpp" | |
39 #include "oops/oop.inline2.hpp" | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
40 #include "oops/symbol.hpp" |
1972 | 41 #include "oops/typeArrayKlass.hpp" |
42 #include "runtime/handles.inline.hpp" | |
43 #ifndef SERIALGC | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
44 #include "gc_implementation/parNew/parOopClosures.inline.hpp" |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
45 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
46 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
47 #include "memory/cardTableRS.hpp" |
1972 | 48 #include "oops/oop.pcgc.inline.hpp" |
49 #endif | |
0 | 50 |
51 int klassKlass::oop_size(oop obj) const { | |
52 assert (obj->is_klass(), "must be a klassOop"); | |
53 return klassOop(obj)->klass_part()->klass_oop_size(); | |
54 } | |
55 | |
56 klassOop klassKlass::create_klass(TRAPS) { | |
57 KlassHandle h_this_klass; | |
58 klassKlass o; | |
59 // for bootstrapping, handles may not be available yet. | |
60 klassOop k = base_create_klass_oop(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL); | |
61 k->set_klass(k); // point to thyself | |
62 // Do not try to allocate mirror, java.lang.Class not loaded at this point. | |
63 // See Universe::fixup_mirrors() | |
64 return k; | |
65 } | |
66 | |
67 void klassKlass::oop_follow_contents(oop obj) { | |
68 Klass* k = Klass::cast(klassOop(obj)); | |
69 // If we are alive it is valid to keep our superclass and subtype caches alive | |
70 MarkSweep::mark_and_push(k->adr_super()); | |
71 for (juint i = 0; i < Klass::primary_super_limit(); i++) | |
72 MarkSweep::mark_and_push(k->adr_primary_supers()+i); | |
73 MarkSweep::mark_and_push(k->adr_secondary_super_cache()); | |
74 MarkSweep::mark_and_push(k->adr_secondary_supers()); | |
75 MarkSweep::mark_and_push(k->adr_java_mirror()); | |
76 // We follow the subklass and sibling links at the end of the | |
77 // marking phase, since otherwise following them will prevent | |
78 // class unloading (all classes are transitively linked from | |
79 // java.lang.Object). | |
80 MarkSweep::revisit_weak_klass_link(k); | |
81 obj->follow_header(); | |
82 } | |
83 | |
84 #ifndef SERIALGC | |
85 void klassKlass::oop_follow_contents(ParCompactionManager* cm, | |
86 oop obj) { | |
87 Klass* k = Klass::cast(klassOop(obj)); | |
88 // If we are alive it is valid to keep our superclass and subtype caches alive | |
89 PSParallelCompact::mark_and_push(cm, k->adr_super()); | |
90 for (juint i = 0; i < Klass::primary_super_limit(); i++) | |
91 PSParallelCompact::mark_and_push(cm, k->adr_primary_supers()+i); | |
92 PSParallelCompact::mark_and_push(cm, k->adr_secondary_super_cache()); | |
93 PSParallelCompact::mark_and_push(cm, k->adr_secondary_supers()); | |
94 PSParallelCompact::mark_and_push(cm, k->adr_java_mirror()); | |
95 // We follow the subklass and sibling links at the end of the | |
96 // marking phase, since otherwise following them will prevent | |
97 // class unloading (all classes are transitively linked from | |
98 // java.lang.Object). | |
99 PSParallelCompact::revisit_weak_klass_link(cm, k); | |
100 obj->follow_header(cm); | |
101 } | |
102 #endif // SERIALGC | |
103 | |
104 int klassKlass::oop_oop_iterate(oop obj, OopClosure* blk) { | |
105 // Get size before changing pointers | |
106 int size = oop_size(obj); | |
107 Klass* k = Klass::cast(klassOop(obj)); | |
108 blk->do_oop(k->adr_super()); | |
109 for (juint i = 0; i < Klass::primary_super_limit(); i++) | |
110 blk->do_oop(k->adr_primary_supers()+i); | |
111 blk->do_oop(k->adr_secondary_super_cache()); | |
112 blk->do_oop(k->adr_secondary_supers()); | |
113 blk->do_oop(k->adr_java_mirror()); | |
114 // The following are in the perm gen and are treated | |
115 // specially in a later phase of a perm gen collection; ... | |
116 assert(oop(k)->is_perm(), "should be in perm"); | |
117 assert(oop(k->subklass())->is_perm_or_null(), "should be in perm"); | |
118 assert(oop(k->next_sibling())->is_perm_or_null(), "should be in perm"); | |
119 // ... don't scan them normally, but remember this klassKlass | |
120 // for later (see, for instance, oop_follow_contents above | |
121 // for what MarkSweep does with it. | |
122 if (blk->should_remember_klasses()) { | |
123 blk->remember_klass(k); | |
124 } | |
125 obj->oop_iterate_header(blk); | |
126 return size; | |
127 } | |
128 | |
129 | |
130 int klassKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | |
131 // Get size before changing pointers | |
132 int size = oop_size(obj); | |
133 Klass* k = Klass::cast(klassOop(obj)); | |
134 oop* adr; | |
135 adr = k->adr_super(); | |
136 if (mr.contains(adr)) blk->do_oop(adr); | |
137 for (juint i = 0; i < Klass::primary_super_limit(); i++) { | |
138 adr = k->adr_primary_supers()+i; | |
139 if (mr.contains(adr)) blk->do_oop(adr); | |
140 } | |
141 adr = k->adr_secondary_super_cache(); | |
142 if (mr.contains(adr)) blk->do_oop(adr); | |
143 adr = k->adr_secondary_supers(); | |
144 if (mr.contains(adr)) blk->do_oop(adr); | |
145 adr = k->adr_java_mirror(); | |
146 if (mr.contains(adr)) blk->do_oop(adr); | |
147 // The following are "weak links" in the perm gen and are | |
148 // treated specially in a later phase of a perm gen collection. | |
149 assert(oop(k)->is_perm(), "should be in perm"); | |
150 assert(oop(k->adr_subklass())->is_perm(), "should be in perm"); | |
151 assert(oop(k->adr_next_sibling())->is_perm(), "should be in perm"); | |
152 if (blk->should_remember_klasses() | |
153 && (mr.contains(k->adr_subklass()) | |
154 || mr.contains(k->adr_next_sibling()))) { | |
155 blk->remember_klass(k); | |
156 } | |
157 obj->oop_iterate_header(blk, mr); | |
158 return size; | |
159 } | |
160 | |
161 | |
162 int klassKlass::oop_adjust_pointers(oop obj) { | |
163 // Get size before changing pointers | |
164 int size = oop_size(obj); | |
165 obj->adjust_header(); | |
166 | |
167 Klass* k = Klass::cast(klassOop(obj)); | |
168 | |
169 MarkSweep::adjust_pointer(k->adr_super()); | |
170 for (juint i = 0; i < Klass::primary_super_limit(); i++) | |
171 MarkSweep::adjust_pointer(k->adr_primary_supers()+i); | |
172 MarkSweep::adjust_pointer(k->adr_secondary_super_cache()); | |
173 MarkSweep::adjust_pointer(k->adr_secondary_supers()); | |
174 MarkSweep::adjust_pointer(k->adr_java_mirror()); | |
175 MarkSweep::adjust_pointer(k->adr_subklass()); | |
176 MarkSweep::adjust_pointer(k->adr_next_sibling()); | |
177 return size; | |
178 } | |
179 | |
180 #ifndef SERIALGC | |
181 void klassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
182 Klass* k = Klass::cast(klassOop(obj)); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
183 |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
184 oop* p = k->adr_java_mirror(); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
185 if (PSScavenge::should_scavenge(p)) { |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
186 pm->claim_or_forward_depth(p); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
187 } |
0 | 188 } |
189 | |
190 int klassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { | |
191 Klass* k = Klass::cast(klassOop(obj)); | |
192 | |
193 oop* const beg_oop = k->oop_block_beg(); | |
194 oop* const end_oop = k->oop_block_end(); | |
195 for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { | |
196 PSParallelCompact::adjust_pointer(cur_oop); | |
197 } | |
198 | |
199 return oop_size(obj); | |
200 } | |
201 #endif // SERIALGC | |
202 | |
203 | |
204 // Printing | |
205 | |
206 void klassKlass::oop_print_on(oop obj, outputStream* st) { | |
207 Klass::oop_print_on(obj, st); | |
208 } | |
209 | |
210 void klassKlass::oop_print_value_on(oop obj, outputStream* st) { | |
211 Klass::oop_print_value_on(obj, st); | |
212 } | |
213 | |
214 const char* klassKlass::internal_name() const { | |
215 return "{other class}"; | |
216 } | |
217 | |
218 | |
219 // Verification | |
220 | |
221 void klassKlass::oop_verify_on(oop obj, outputStream* st) { | |
222 Klass::oop_verify_on(obj, st); | |
223 guarantee(obj->is_perm(), "should be in permspace"); | |
224 guarantee(obj->is_klass(), "should be klass"); | |
225 | |
226 Klass* k = Klass::cast(klassOop(obj)); | |
227 if (k->super() != NULL) { | |
228 guarantee(k->super()->is_perm(), "should be in permspace"); | |
229 guarantee(k->super()->is_klass(), "should be klass"); | |
230 } | |
231 klassOop ko = k->secondary_super_cache(); | |
232 if( ko != NULL ) { | |
233 guarantee(ko->is_perm(), "should be in permspace"); | |
234 guarantee(ko->is_klass(), "should be klass"); | |
235 } | |
236 for( uint i = 0; i < primary_super_limit(); i++ ) { | |
237 oop ko = k->adr_primary_supers()[i]; // Cannot use normal accessor because it asserts | |
238 if( ko != NULL ) { | |
239 guarantee(ko->is_perm(), "should be in permspace"); | |
240 guarantee(ko->is_klass(), "should be klass"); | |
241 } | |
242 } | |
243 | |
244 if (k->java_mirror() != NULL || (k->oop_is_instance() && instanceKlass::cast(klassOop(obj))->is_loaded())) { | |
245 guarantee(k->java_mirror() != NULL, "should be allocated"); | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
246 guarantee(k->java_mirror()->is_perm() || !JavaObjectsInPerm, "should be in permspace"); |
0 | 247 guarantee(k->java_mirror()->is_instance(), "should be instance"); |
248 } | |
249 } |