Mercurial > hg > truffle
annotate src/share/vm/oops/cpCacheKlass.cpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
author | tonyp |
---|---|
date | Fri, 16 Dec 2011 02:14:27 -0500 |
parents | baf763f388e6 |
children |
rev | line source |
---|---|
0 | 1 /* |
2227 | 2 * Copyright (c) 1998, 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 "classfile/javaClasses.hpp" | |
27 #include "gc_implementation/shared/markSweep.inline.hpp" | |
28 #include "gc_interface/collectedHeap.hpp" | |
29 #include "interpreter/bytecodes.hpp" | |
30 #include "memory/genOopClosures.inline.hpp" | |
31 #include "memory/permGen.hpp" | |
32 #include "oops/constantPoolOop.hpp" | |
33 #include "oops/cpCacheKlass.hpp" | |
34 #include "oops/oop.inline.hpp" | |
35 #include "runtime/handles.inline.hpp" | |
36 #ifndef SERIALGC | |
37 #include "gc_implementation/parNew/parOopClosures.inline.hpp" | |
38 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" | |
39 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" | |
40 #include "memory/cardTableRS.hpp" | |
41 #include "oops/oop.pcgc.inline.hpp" | |
42 #endif | |
0 | 43 |
44 | |
45 int constantPoolCacheKlass::oop_size(oop obj) const { | |
46 assert(obj->is_constantPoolCache(), "must be constantPool"); | |
47 return constantPoolCacheOop(obj)->object_size(); | |
48 } | |
49 | |
50 | |
542
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
51 constantPoolCacheOop constantPoolCacheKlass::allocate(int length, |
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
52 TRAPS) { |
0 | 53 // allocate memory |
54 int size = constantPoolCacheOopDesc::object_size(length); | |
542
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
55 |
0 | 56 KlassHandle klass (THREAD, as_klassOop()); |
542
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
57 |
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
58 // Commented out below is the original code. The code from |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
59 // permanent_obj_allocate() was in-lined so that we could |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
60 // set the _length field, necessary to correctly compute its |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
61 // size(), before setting its klass word further below. |
542
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
62 // constantPoolCacheOop cache = (constantPoolCacheOop) |
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
63 // CollectedHeap::permanent_obj_allocate(klass, size, CHECK_NULL); |
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
64 |
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
65 oop obj = CollectedHeap::permanent_obj_allocate_no_klass_install(klass, size, CHECK_NULL); |
3892 | 66 #ifndef PRODUCT |
67 const size_t hs = oopDesc::header_size(); | |
68 Universe::heap()->check_for_bad_heap_word_value(((HeapWord*) obj)+hs, size-hs); | |
69 #endif | |
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
70 constantPoolCacheOop cache = (constantPoolCacheOop) obj; |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
71 assert(!UseConcMarkSweepGC || obj->klass_or_null() == NULL, |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
72 "klass should be NULL here when using CMS"); |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
73 cache->set_length(length); // should become visible before klass is set below. |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
74 cache->set_constant_pool(NULL); |
542
9a25e0c45327
6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents:
196
diff
changeset
|
75 |
2226
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
76 OrderAccess::storestore(); |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
77 obj->set_klass(klass()); |
c5a923563727
6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents:
1972
diff
changeset
|
78 assert(cache->size() == size, "Incorrect cache->size()"); |
0 | 79 return cache; |
80 } | |
81 | |
82 klassOop constantPoolCacheKlass::create_klass(TRAPS) { | |
83 constantPoolCacheKlass o; | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
84 KlassHandle h_this_klass(THREAD, Universe::klassKlassObj()); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
85 KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
86 // Make sure size calculation is right |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
87 assert(k()->size() == align_object_size(header_size()), "wrong size for object"); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
88 java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror |
0 | 89 return k(); |
90 } | |
91 | |
92 | |
93 void constantPoolCacheKlass::oop_follow_contents(oop obj) { | |
94 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
95 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
96 // Performance tweak: We skip iterating over the klass pointer since we | |
97 // know that Universe::constantPoolCacheKlassObj never moves. | |
98 // gc of constant pool cache instance variables | |
99 MarkSweep::mark_and_push((oop*)cache->constant_pool_addr()); | |
100 // gc of constant pool cache entries | |
101 int i = cache->length(); | |
102 while (i-- > 0) cache->entry_at(i)->follow_contents(); | |
103 } | |
104 | |
105 #ifndef SERIALGC | |
106 void constantPoolCacheKlass::oop_follow_contents(ParCompactionManager* cm, | |
107 oop obj) { | |
108 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
109 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
110 // Performance tweak: We skip iterating over the klass pointer since we | |
111 // know that Universe::constantPoolCacheKlassObj never moves. | |
112 // gc of constant pool cache instance variables | |
113 PSParallelCompact::mark_and_push(cm, (oop*)cache->constant_pool_addr()); | |
114 // gc of constant pool cache entries | |
115 int i = cache->length(); | |
116 while (i-- > 0) cache->entry_at(i)->follow_contents(cm); | |
117 } | |
118 #endif // SERIALGC | |
119 | |
120 | |
121 int constantPoolCacheKlass::oop_oop_iterate(oop obj, OopClosure* blk) { | |
122 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
123 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
124 // Get size before changing pointers. | |
125 // Don't call size() or oop_size() since that is a virtual call. | |
126 int size = cache->object_size(); | |
127 // Performance tweak: We skip iterating over the klass pointer since we | |
128 // know that Universe::constantPoolCacheKlassObj never moves. | |
129 // iteration over constant pool cache instance variables | |
130 blk->do_oop((oop*)cache->constant_pool_addr()); | |
131 // iteration over constant pool cache entries | |
132 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate(blk); | |
133 return size; | |
134 } | |
135 | |
136 | |
137 int constantPoolCacheKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | |
138 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
139 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
140 // Get size before changing pointers. | |
141 // Don't call size() or oop_size() since that is a virtual call. | |
142 int size = cache->object_size(); | |
143 // Performance tweak: We skip iterating over the klass pointer since we | |
144 // know that Universe::constantPoolCacheKlassObj never moves. | |
145 // iteration over constant pool cache instance variables | |
146 oop* addr = (oop*)cache->constant_pool_addr(); | |
147 if (mr.contains(addr)) blk->do_oop(addr); | |
148 // iteration over constant pool cache entries | |
149 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->oop_iterate_m(blk, mr); | |
150 return size; | |
151 } | |
152 | |
153 int constantPoolCacheKlass::oop_adjust_pointers(oop obj) { | |
154 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
155 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
156 // Get size before changing pointers. | |
157 // Don't call size() or oop_size() since that is a virtual call. | |
158 int size = cache->object_size(); | |
159 // Performance tweak: We skip iterating over the klass pointer since we | |
160 // know that Universe::constantPoolCacheKlassObj never moves. | |
161 // Iteration over constant pool cache instance variables | |
162 MarkSweep::adjust_pointer((oop*)cache->constant_pool_addr()); | |
163 // iteration over constant pool cache entries | |
164 for (int i = 0; i < cache->length(); i++) | |
165 cache->entry_at(i)->adjust_pointers(); | |
166 return size; | |
167 } | |
168 | |
169 #ifndef SERIALGC | |
170 void constantPoolCacheKlass::oop_push_contents(PSPromotionManager* pm, | |
171 oop obj) { | |
172 assert(obj->is_constantPoolCache(), "should be constant pool"); | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
173 if (ScavengeRootsInCode) { |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
174 constantPoolCacheOop cache = (constantPoolCacheOop)obj; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
175 // during a scavenge, it is safe to inspect my pool, since it is perm |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
176 constantPoolOop pool = cache->constant_pool(); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
177 assert(pool->is_constantPool(), "should be constant pool"); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
178 for (int i = 0; i < cache->length(); i++) { |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
179 ConstantPoolCacheEntry* e = cache->entry_at(i); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
180 oop* p = (oop*)&e->_f1; |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
181 if (PSScavenge::should_scavenge(p)) |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
182 pm->claim_or_forward_depth(p); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
183 assert(!(e->is_vfinal() && PSScavenge::should_scavenge((oop*)&e->_f2)), |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2227
diff
changeset
|
184 "no live oops here"); |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
185 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
579
diff
changeset
|
186 } |
0 | 187 } |
188 | |
189 int | |
190 constantPoolCacheKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { | |
191 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
192 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
193 | |
194 // Iteration over constant pool cache instance variables | |
195 PSParallelCompact::adjust_pointer((oop*)cache->constant_pool_addr()); | |
196 | |
197 // iteration over constant pool cache entries | |
198 for (int i = 0; i < cache->length(); ++i) { | |
199 cache->entry_at(i)->update_pointers(); | |
200 } | |
201 | |
202 return cache->object_size(); | |
203 } | |
204 #endif // SERIALGC | |
205 | |
206 void constantPoolCacheKlass::oop_print_on(oop obj, outputStream* st) { | |
207 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
208 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
209 // super print | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
210 Klass::oop_print_on(obj, st); |
0 | 211 // print constant pool cache entries |
212 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->print(st, i); | |
213 } | |
214 | |
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
215 void constantPoolCacheKlass::oop_print_value_on(oop obj, outputStream* st) { |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
216 assert(obj->is_constantPoolCache(), "obj must be constant pool cache"); |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
217 constantPoolCacheOop cache = (constantPoolCacheOop)obj; |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
218 st->print("cache [%d]", cache->length()); |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
219 cache->print_address_on(st); |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
220 st->print(" for "); |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
221 cache->constant_pool()->print_value_on(st); |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
222 } |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
726
diff
changeset
|
223 |
0 | 224 void constantPoolCacheKlass::oop_verify_on(oop obj, outputStream* st) { |
225 guarantee(obj->is_constantPoolCache(), "obj must be constant pool cache"); | |
226 constantPoolCacheOop cache = (constantPoolCacheOop)obj; | |
227 // super verify | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
228 Klass::oop_verify_on(obj, st); |
0 | 229 // print constant pool cache entries |
230 for (int i = 0; i < cache->length(); i++) cache->entry_at(i)->verify(st); | |
231 } | |
232 | |
233 | |
234 const char* constantPoolCacheKlass::internal_name() const { | |
235 return "{constant pool cache}"; | |
236 } |