Mercurial > hg > truffle
annotate src/share/vm/oops/typeArrayKlass.cpp @ 3774:c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
Summary: Remove two unused parameters from the mem_allocate() method and update its uses accordingly.
Reviewed-by: stefank, johnc
| author | tonyp |
|---|---|
| date | Thu, 16 Jun 2011 15:51:57 -0400 |
| parents | e5383553fd4e |
| children | a92cdbac8b9e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2119 | 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:
1334
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1334
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:
1334
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "gc_interface/collectedHeap.hpp" | |
| 29 #include "gc_interface/collectedHeap.inline.hpp" | |
| 30 #include "memory/resourceArea.hpp" | |
| 31 #include "memory/universe.hpp" | |
| 32 #include "memory/universe.inline.hpp" | |
| 33 #include "oops/instanceKlass.hpp" | |
| 34 #include "oops/klassOop.hpp" | |
| 35 #include "oops/objArrayKlassKlass.hpp" | |
| 36 #include "oops/oop.inline.hpp" | |
| 37 #include "oops/typeArrayKlass.hpp" | |
| 38 #include "oops/typeArrayOop.hpp" | |
| 39 #include "runtime/handles.inline.hpp" | |
| 0 | 40 |
| 41 bool typeArrayKlass::compute_is_subtype_of(klassOop k) { | |
| 42 if (!k->klass_part()->oop_is_typeArray()) { | |
| 43 return arrayKlass::compute_is_subtype_of(k); | |
| 44 } | |
| 45 | |
| 46 typeArrayKlass* tak = typeArrayKlass::cast(k); | |
| 47 if (dimension() != tak->dimension()) return false; | |
| 48 | |
| 49 return element_type() == tak->element_type(); | |
| 50 } | |
| 51 | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
0
diff
changeset
|
52 klassOop typeArrayKlass::create_klass(BasicType type, int scale, |
|
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
0
diff
changeset
|
53 const char* name_str, TRAPS) { |
| 0 | 54 typeArrayKlass o; |
| 55 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
56 Symbol* sym = NULL; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
57 if (name_str != NULL) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
58 sym = SymbolTable::new_symbol(name_str, CHECK_NULL); |
| 0 | 59 } |
| 60 KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj()); | |
| 61 | |
| 62 arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL); | |
| 63 typeArrayKlass* ak = typeArrayKlass::cast(k()); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
64 ak->set_name(sym); |
| 0 | 65 ak->set_layout_helper(array_layout_helper(type)); |
| 66 assert(scale == (1 << ak->log2_element_size()), "scale must check out"); | |
| 67 assert(ak->oop_is_javaArray(), "sanity"); | |
| 68 assert(ak->oop_is_typeArray(), "sanity"); | |
| 69 ak->set_max_length(arrayOopDesc::max_array_length(type)); | |
| 70 assert(k()->size() > header_size(), "bad size"); | |
| 71 | |
| 72 // Call complete_create_array_klass after all instance variables have been initialized. | |
| 73 KlassHandle super (THREAD, k->super()); | |
| 74 complete_create_array_klass(k, super, CHECK_NULL); | |
| 75 | |
| 76 return k(); | |
| 77 } | |
| 78 | |
| 79 typeArrayOop typeArrayKlass::allocate(int length, TRAPS) { | |
| 80 assert(log2_element_size() >= 0, "bad scale"); | |
| 81 if (length >= 0) { | |
| 82 if (length <= max_length()) { | |
| 83 size_t size = typeArrayOopDesc::object_size(layout_helper(), length); | |
| 84 KlassHandle h_k(THREAD, as_klassOop()); | |
| 85 typeArrayOop t; | |
| 86 CollectedHeap* ch = Universe::heap(); | |
|
3774
c9ca3f51cf41
6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents:
2227
diff
changeset
|
87 t = (typeArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL); |
| 0 | 88 assert(t->is_parsable(), "Don't publish unless parsable"); |
| 89 return t; | |
| 90 } else { | |
|
876
1413494da700
6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit
martin
parents:
579
diff
changeset
|
91 report_java_out_of_memory("Requested array size exceeds VM limit"); |
| 0 | 92 THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
| 93 } | |
| 94 } else { | |
| 95 THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); | |
| 96 } | |
| 97 } | |
| 98 | |
| 99 typeArrayOop typeArrayKlass::allocate_permanent(int length, TRAPS) { | |
| 100 if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); | |
| 101 int size = typeArrayOopDesc::object_size(layout_helper(), length); | |
| 102 KlassHandle h_k(THREAD, as_klassOop()); | |
| 103 typeArrayOop t = (typeArrayOop) | |
| 104 CollectedHeap::permanent_array_allocate(h_k, size, length, CHECK_NULL); | |
| 105 assert(t->is_parsable(), "Can't publish until parsable"); | |
| 106 return t; | |
| 107 } | |
| 108 | |
| 109 oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) { | |
| 110 // For typeArrays this is only called for the last dimension | |
| 111 assert(rank == 1, "just checking"); | |
| 112 int length = *last_size; | |
| 113 return allocate(length, THREAD); | |
| 114 } | |
| 115 | |
| 116 | |
| 117 void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) { | |
| 118 assert(s->is_typeArray(), "must be type array"); | |
| 119 | |
| 120 // Check destination | |
| 121 if (!d->is_typeArray() || element_type() != typeArrayKlass::cast(d->klass())->element_type()) { | |
| 122 THROW(vmSymbols::java_lang_ArrayStoreException()); | |
| 123 } | |
| 124 | |
| 125 // Check is all offsets and lengths are non negative | |
| 126 if (src_pos < 0 || dst_pos < 0 || length < 0) { | |
| 127 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); | |
| 128 } | |
| 129 // Check if the ranges are valid | |
| 130 if ( (((unsigned int) length + (unsigned int) src_pos) > (unsigned int) s->length()) | |
| 131 || (((unsigned int) length + (unsigned int) dst_pos) > (unsigned int) d->length()) ) { | |
| 132 THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); | |
| 133 } | |
|
1334
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
134 // Check zero copy |
|
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
135 if (length == 0) |
|
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
136 return; |
| 0 | 137 |
| 138 // This is an attempt to make the copy_array fast. | |
| 139 int l2es = log2_element_size(); | |
| 140 int ihs = array_header_in_bytes() / wordSize; | |
|
1334
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
141 char* src = (char*) ((oop*)s + ihs) + ((size_t)src_pos << l2es); |
|
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
142 char* dst = (char*) ((oop*)d + ihs) + ((size_t)dst_pos << l2es); |
|
b5d78a3b8843
6892265: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
kvn
parents:
876
diff
changeset
|
143 Copy::conjoint_memory_atomic(src, dst, (size_t)length << l2es); |
| 0 | 144 } |
| 145 | |
| 146 | |
| 147 // create a klass of array holding typeArrays | |
| 148 klassOop typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) { | |
| 149 typeArrayKlassHandle h_this(THREAD, as_klassOop()); | |
| 150 return array_klass_impl(h_this, or_null, n, THREAD); | |
| 151 } | |
| 152 | |
| 153 klassOop typeArrayKlass::array_klass_impl(typeArrayKlassHandle h_this, bool or_null, int n, TRAPS) { | |
| 154 int dimension = h_this->dimension(); | |
| 155 assert(dimension <= n, "check order of chain"); | |
| 156 if (dimension == n) | |
| 157 return h_this(); | |
| 158 | |
| 159 objArrayKlassHandle h_ak(THREAD, h_this->higher_dimension()); | |
| 160 if (h_ak.is_null()) { | |
| 161 if (or_null) return NULL; | |
| 162 | |
| 163 ResourceMark rm; | |
| 164 JavaThread *jt = (JavaThread *)THREAD; | |
| 165 { | |
| 166 MutexLocker mc(Compile_lock, THREAD); // for vtables | |
| 167 // Atomic create higher dimension and link into list | |
| 168 MutexLocker mu(MultiArray_lock, THREAD); | |
| 169 | |
| 170 h_ak = objArrayKlassHandle(THREAD, h_this->higher_dimension()); | |
| 171 if (h_ak.is_null()) { | |
| 172 klassOop oak = objArrayKlassKlass::cast( | |
| 173 Universe::objArrayKlassKlassObj())->allocate_objArray_klass( | |
| 174 dimension + 1, h_this, CHECK_NULL); | |
| 175 h_ak = objArrayKlassHandle(THREAD, oak); | |
| 176 h_ak->set_lower_dimension(h_this()); | |
| 2119 | 177 OrderAccess::storestore(); |
| 0 | 178 h_this->set_higher_dimension(h_ak()); |
| 179 assert(h_ak->oop_is_objArray(), "incorrect initialization of objArrayKlass"); | |
| 180 } | |
| 181 } | |
| 182 } else { | |
| 183 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); | |
| 184 } | |
| 185 if (or_null) { | |
| 186 return h_ak->array_klass_or_null(n); | |
| 187 } | |
| 188 return h_ak->array_klass(n, CHECK_NULL); | |
| 189 } | |
| 190 | |
| 191 klassOop typeArrayKlass::array_klass_impl(bool or_null, TRAPS) { | |
| 192 return array_klass_impl(or_null, dimension() + 1, THREAD); | |
| 193 } | |
| 194 | |
| 195 int typeArrayKlass::oop_size(oop obj) const { | |
| 196 assert(obj->is_typeArray(),"must be a type array"); | |
| 197 typeArrayOop t = typeArrayOop(obj); | |
| 198 return t->object_size(); | |
| 199 } | |
| 200 | |
| 201 void typeArrayKlass::oop_follow_contents(oop obj) { | |
| 202 assert(obj->is_typeArray(),"must be a type array"); | |
| 203 // Performance tweak: We skip iterating over the klass pointer since we | |
| 204 // know that Universe::typeArrayKlass never moves. | |
| 205 } | |
| 206 | |
| 207 #ifndef SERIALGC | |
| 208 void typeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { | |
| 209 assert(obj->is_typeArray(),"must be a type array"); | |
| 210 // Performance tweak: We skip iterating over the klass pointer since we | |
| 211 // know that Universe::typeArrayKlass never moves. | |
| 212 } | |
| 213 #endif // SERIALGC | |
| 214 | |
| 215 int typeArrayKlass::oop_adjust_pointers(oop obj) { | |
| 216 assert(obj->is_typeArray(),"must be a type array"); | |
| 217 typeArrayOop t = typeArrayOop(obj); | |
| 218 // Performance tweak: We skip iterating over the klass pointer since we | |
| 219 // know that Universe::typeArrayKlass never moves. | |
| 220 return t->object_size(); | |
| 221 } | |
| 222 | |
| 223 int typeArrayKlass::oop_oop_iterate(oop obj, OopClosure* blk) { | |
| 224 assert(obj->is_typeArray(),"must be a type array"); | |
| 225 typeArrayOop t = typeArrayOop(obj); | |
| 226 // Performance tweak: We skip iterating over the klass pointer since we | |
| 227 // know that Universe::typeArrayKlass never moves. | |
| 228 return t->object_size(); | |
| 229 } | |
| 230 | |
| 231 int typeArrayKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, MemRegion mr) { | |
| 232 assert(obj->is_typeArray(),"must be a type array"); | |
| 233 typeArrayOop t = typeArrayOop(obj); | |
| 234 // Performance tweak: We skip iterating over the klass pointer since we | |
| 235 // know that Universe::typeArrayKlass never moves. | |
| 236 return t->object_size(); | |
| 237 } | |
| 238 | |
| 239 #ifndef SERIALGC | |
| 240 void typeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { | |
| 241 assert(obj->is_typeArray(),"must be a type array"); | |
| 242 } | |
| 243 | |
| 244 int | |
| 245 typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { | |
| 246 assert(obj->is_typeArray(),"must be a type array"); | |
| 247 return typeArrayOop(obj)->object_size(); | |
| 248 } | |
| 249 #endif // SERIALGC | |
| 250 | |
| 251 void typeArrayKlass::initialize(TRAPS) { | |
| 252 // Nothing to do. Having this function is handy since objArrayKlasses can be | |
| 253 // initialized by calling initialize on their bottom_klass, see objArrayKlass::initialize | |
| 254 } | |
| 255 | |
| 256 const char* typeArrayKlass::external_name(BasicType type) { | |
| 257 switch (type) { | |
| 258 case T_BOOLEAN: return "[Z"; | |
| 259 case T_CHAR: return "[C"; | |
| 260 case T_FLOAT: return "[F"; | |
| 261 case T_DOUBLE: return "[D"; | |
| 262 case T_BYTE: return "[B"; | |
| 263 case T_SHORT: return "[S"; | |
| 264 case T_INT: return "[I"; | |
| 265 case T_LONG: return "[J"; | |
| 266 default: ShouldNotReachHere(); | |
| 267 } | |
| 268 return NULL; | |
| 269 } | |
| 270 | |
| 271 #ifndef PRODUCT | |
| 272 // Printing | |
| 273 | |
| 274 static void print_boolean_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 275 for (int index = 0; index < print_len; index++) { | |
| 276 st->print_cr(" - %3d: %s", index, (ta->bool_at(index) == 0) ? "false" : "true"); | |
| 277 } | |
| 278 } | |
| 279 | |
| 280 | |
| 281 static void print_char_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 282 for (int index = 0; index < print_len; index++) { | |
| 283 jchar c = ta->char_at(index); | |
| 284 st->print_cr(" - %3d: %x %c", index, c, isprint(c) ? c : ' '); | |
| 285 } | |
| 286 } | |
| 287 | |
| 288 | |
| 289 static void print_float_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 290 for (int index = 0; index < print_len; index++) { | |
| 291 st->print_cr(" - %3d: %g", index, ta->float_at(index)); | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 | |
| 296 static void print_double_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 297 for (int index = 0; index < print_len; index++) { | |
| 298 st->print_cr(" - %3d: %g", index, ta->double_at(index)); | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 | |
| 303 static void print_byte_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 304 for (int index = 0; index < print_len; index++) { | |
| 305 jbyte c = ta->byte_at(index); | |
| 306 st->print_cr(" - %3d: %x %c", index, c, isprint(c) ? c : ' '); | |
| 307 } | |
| 308 } | |
| 309 | |
| 310 | |
| 311 static void print_short_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 312 for (int index = 0; index < print_len; index++) { | |
| 313 int v = ta->ushort_at(index); | |
| 314 st->print_cr(" - %3d: 0x%x\t %d", index, v, v); | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 | |
| 319 static void print_int_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 320 for (int index = 0; index < print_len; index++) { | |
| 321 jint v = ta->int_at(index); | |
| 322 st->print_cr(" - %3d: 0x%x %d", index, v, v); | |
| 323 } | |
| 324 } | |
| 325 | |
| 326 | |
| 327 static void print_long_array(typeArrayOop ta, int print_len, outputStream* st) { | |
| 328 for (int index = 0; index < print_len; index++) { | |
| 329 jlong v = ta->long_at(index); | |
| 330 st->print_cr(" - %3d: 0x%x 0x%x", index, high(v), low(v)); | |
| 331 } | |
| 332 } | |
| 333 | |
| 334 | |
| 335 void typeArrayKlass::oop_print_on(oop obj, outputStream* st) { | |
| 336 arrayKlass::oop_print_on(obj, st); | |
| 337 typeArrayOop ta = typeArrayOop(obj); | |
| 338 int print_len = MIN2((intx) ta->length(), MaxElementPrintSize); | |
| 339 switch (element_type()) { | |
| 340 case T_BOOLEAN: print_boolean_array(ta, print_len, st); break; | |
| 341 case T_CHAR: print_char_array(ta, print_len, st); break; | |
| 342 case T_FLOAT: print_float_array(ta, print_len, st); break; | |
| 343 case T_DOUBLE: print_double_array(ta, print_len, st); break; | |
| 344 case T_BYTE: print_byte_array(ta, print_len, st); break; | |
| 345 case T_SHORT: print_short_array(ta, print_len, st); break; | |
| 346 case T_INT: print_int_array(ta, print_len, st); break; | |
| 347 case T_LONG: print_long_array(ta, print_len, st); break; | |
| 348 default: ShouldNotReachHere(); | |
| 349 } | |
| 350 int remaining = ta->length() - print_len; | |
| 351 if (remaining > 0) { | |
| 352 tty->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining); | |
| 353 } | |
| 354 } | |
| 355 | |
| 356 #endif // PRODUCT | |
| 357 | |
| 358 const char* typeArrayKlass::internal_name() const { | |
| 359 return Klass::external_name(); | |
| 360 } |