22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "aot/aotLoader.hpp"
27 #include "classfile/classLoader.hpp"
28 #include "classfile/classLoaderDataGraph.hpp"
29 #include "classfile/javaClasses.hpp"
30 #include "classfile/stringTable.hpp"
31 #include "classfile/systemDictionary.hpp"
32 #include "classfile/vmSymbols.hpp"
33 #include "code/codeCache.hpp"
34 #include "code/dependencies.hpp"
35 #include "gc/shared/collectedHeap.inline.hpp"
36 #include "gc/shared/gcArguments.hpp"
37 #include "gc/shared/gcConfig.hpp"
38 #include "gc/shared/gcTraceTime.inline.hpp"
39 #include "interpreter/interpreter.hpp"
40 #include "logging/log.hpp"
41 #include "logging/logStream.hpp"
42 #include "memory/filemap.hpp"
43 #include "memory/metadataFactory.hpp"
44 #include "memory/metaspaceClosure.hpp"
45 #include "memory/metaspaceCounters.hpp"
46 #include "memory/metaspaceShared.hpp"
47 #include "memory/oopFactory.hpp"
48 #include "memory/resourceArea.hpp"
49 #include "memory/universe.hpp"
50 #include "memory/universe.hpp"
51 #include "oops/constantPool.hpp"
52 #include "oops/instanceClassLoaderKlass.hpp"
53 #include "oops/instanceKlass.hpp"
54 #include "oops/instanceMirrorKlass.hpp"
55 #include "oops/instanceRefKlass.hpp"
56 #include "oops/objArrayOop.inline.hpp"
57 #include "oops/oop.inline.hpp"
58 #include "oops/typeArrayKlass.hpp"
59 #include "prims/resolvedMethodTable.hpp"
60 #include "runtime/arguments.hpp"
61 #include "runtime/atomic.hpp"
223 it->push(&_the_empty_instance_klass_array);
224 it->push(&_the_empty_method_array);
225 it->push(&_the_array_interfaces_array);
226
227 _finalizer_register_cache->metaspace_pointers_do(it);
228 _loader_addClass_cache->metaspace_pointers_do(it);
229 _pd_implies_cache->metaspace_pointers_do(it);
230 _throw_illegal_access_error_cache->metaspace_pointers_do(it);
231 _do_stack_walk_cache->metaspace_pointers_do(it);
232 }
233
234 // Serialize metadata and pointers to primitive type mirrors in and out of CDS archive
235 void Universe::serialize(SerializeClosure* f) {
236
237 for (int i = 0; i < T_LONG+1; i++) {
238 f->do_ptr((void**)&_typeArrayKlassObjs[i]);
239 }
240
241 f->do_ptr((void**)&_objectArrayKlassObj);
242 #if INCLUDE_CDS_JAVA_HEAP
243 // The mirrors are NULL if MetaspaceShared::is_heap_object_archiving_allowed
244 // is false.
245 f->do_oop(&_int_mirror);
246 f->do_oop(&_float_mirror);
247 f->do_oop(&_double_mirror);
248 f->do_oop(&_byte_mirror);
249 f->do_oop(&_bool_mirror);
250 f->do_oop(&_char_mirror);
251 f->do_oop(&_long_mirror);
252 f->do_oop(&_short_mirror);
253 f->do_oop(&_void_mirror);
254 #endif
255
256 f->do_ptr((void**)&_the_array_interfaces_array);
257 f->do_ptr((void**)&_the_empty_int_array);
258 f->do_ptr((void**)&_the_empty_short_array);
259 f->do_ptr((void**)&_the_empty_method_array);
260 f->do_ptr((void**)&_the_empty_klass_array);
261 f->do_ptr((void**)&_the_empty_instance_klass_array);
262 _finalizer_register_cache->serialize(f);
263 _loader_addClass_cache->serialize(f);
403 oop dummy = SystemDictionary::Object_klass()->allocate_instance(CHECK);
404 dummy_array->obj_at_put(i++, dummy);
405 }
406 {
407 // Only modify the global variable inside the mutex.
408 // If we had a race to here, the other dummy_array instances
409 // and their elements just get dropped on the floor, which is fine.
410 MutexLocker ml(FullGCALot_lock);
411 if (_fullgc_alot_dummy_array == NULL) {
412 _fullgc_alot_dummy_array = dummy_array();
413 }
414 }
415 assert(i == _fullgc_alot_dummy_array->length(), "just checking");
416 }
417 #endif
418 }
419
420 void Universe::initialize_basic_type_mirrors(TRAPS) {
421 #if INCLUDE_CDS_JAVA_HEAP
422 if (UseSharedSpaces &&
423 MetaspaceShared::open_archive_heap_region_mapped() &&
424 _int_mirror != NULL) {
425 assert(MetaspaceShared::is_heap_object_archiving_allowed(), "Sanity");
426 assert(_float_mirror != NULL && _double_mirror != NULL &&
427 _byte_mirror != NULL && _byte_mirror != NULL &&
428 _bool_mirror != NULL && _char_mirror != NULL &&
429 _long_mirror != NULL && _short_mirror != NULL &&
430 _void_mirror != NULL, "Sanity");
431 } else
432 #endif
433 {
434 _int_mirror =
435 java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK);
436 _float_mirror =
437 java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK);
438 _double_mirror =
439 java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK);
440 _byte_mirror =
441 java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK);
442 _bool_mirror =
443 java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK);
444 _char_mirror =
445 java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK);
|
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "aot/aotLoader.hpp"
27 #include "classfile/classLoader.hpp"
28 #include "classfile/classLoaderDataGraph.hpp"
29 #include "classfile/javaClasses.hpp"
30 #include "classfile/stringTable.hpp"
31 #include "classfile/systemDictionary.hpp"
32 #include "classfile/vmSymbols.hpp"
33 #include "code/codeCache.hpp"
34 #include "code/dependencies.hpp"
35 #include "gc/shared/collectedHeap.inline.hpp"
36 #include "gc/shared/gcArguments.hpp"
37 #include "gc/shared/gcConfig.hpp"
38 #include "gc/shared/gcTraceTime.inline.hpp"
39 #include "interpreter/interpreter.hpp"
40 #include "logging/log.hpp"
41 #include "logging/logStream.hpp"
42 #include "memory/heapShared.hpp"
43 #include "memory/filemap.hpp"
44 #include "memory/metadataFactory.hpp"
45 #include "memory/metaspaceClosure.hpp"
46 #include "memory/metaspaceCounters.hpp"
47 #include "memory/metaspaceShared.hpp"
48 #include "memory/oopFactory.hpp"
49 #include "memory/resourceArea.hpp"
50 #include "memory/universe.hpp"
51 #include "memory/universe.hpp"
52 #include "oops/constantPool.hpp"
53 #include "oops/instanceClassLoaderKlass.hpp"
54 #include "oops/instanceKlass.hpp"
55 #include "oops/instanceMirrorKlass.hpp"
56 #include "oops/instanceRefKlass.hpp"
57 #include "oops/objArrayOop.inline.hpp"
58 #include "oops/oop.inline.hpp"
59 #include "oops/typeArrayKlass.hpp"
60 #include "prims/resolvedMethodTable.hpp"
61 #include "runtime/arguments.hpp"
62 #include "runtime/atomic.hpp"
224 it->push(&_the_empty_instance_klass_array);
225 it->push(&_the_empty_method_array);
226 it->push(&_the_array_interfaces_array);
227
228 _finalizer_register_cache->metaspace_pointers_do(it);
229 _loader_addClass_cache->metaspace_pointers_do(it);
230 _pd_implies_cache->metaspace_pointers_do(it);
231 _throw_illegal_access_error_cache->metaspace_pointers_do(it);
232 _do_stack_walk_cache->metaspace_pointers_do(it);
233 }
234
235 // Serialize metadata and pointers to primitive type mirrors in and out of CDS archive
236 void Universe::serialize(SerializeClosure* f) {
237
238 for (int i = 0; i < T_LONG+1; i++) {
239 f->do_ptr((void**)&_typeArrayKlassObjs[i]);
240 }
241
242 f->do_ptr((void**)&_objectArrayKlassObj);
243 #if INCLUDE_CDS_JAVA_HEAP
244 // The mirrors are NULL if HeapShared::is_heap_object_archiving_allowed
245 // is false.
246 f->do_oop(&_int_mirror);
247 f->do_oop(&_float_mirror);
248 f->do_oop(&_double_mirror);
249 f->do_oop(&_byte_mirror);
250 f->do_oop(&_bool_mirror);
251 f->do_oop(&_char_mirror);
252 f->do_oop(&_long_mirror);
253 f->do_oop(&_short_mirror);
254 f->do_oop(&_void_mirror);
255 #endif
256
257 f->do_ptr((void**)&_the_array_interfaces_array);
258 f->do_ptr((void**)&_the_empty_int_array);
259 f->do_ptr((void**)&_the_empty_short_array);
260 f->do_ptr((void**)&_the_empty_method_array);
261 f->do_ptr((void**)&_the_empty_klass_array);
262 f->do_ptr((void**)&_the_empty_instance_klass_array);
263 _finalizer_register_cache->serialize(f);
264 _loader_addClass_cache->serialize(f);
404 oop dummy = SystemDictionary::Object_klass()->allocate_instance(CHECK);
405 dummy_array->obj_at_put(i++, dummy);
406 }
407 {
408 // Only modify the global variable inside the mutex.
409 // If we had a race to here, the other dummy_array instances
410 // and their elements just get dropped on the floor, which is fine.
411 MutexLocker ml(FullGCALot_lock);
412 if (_fullgc_alot_dummy_array == NULL) {
413 _fullgc_alot_dummy_array = dummy_array();
414 }
415 }
416 assert(i == _fullgc_alot_dummy_array->length(), "just checking");
417 }
418 #endif
419 }
420
421 void Universe::initialize_basic_type_mirrors(TRAPS) {
422 #if INCLUDE_CDS_JAVA_HEAP
423 if (UseSharedSpaces &&
424 HeapShared::open_archive_heap_region_mapped() &&
425 _int_mirror != NULL) {
426 assert(HeapShared::is_heap_object_archiving_allowed(), "Sanity");
427 assert(_float_mirror != NULL && _double_mirror != NULL &&
428 _byte_mirror != NULL && _byte_mirror != NULL &&
429 _bool_mirror != NULL && _char_mirror != NULL &&
430 _long_mirror != NULL && _short_mirror != NULL &&
431 _void_mirror != NULL, "Sanity");
432 } else
433 #endif
434 {
435 _int_mirror =
436 java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK);
437 _float_mirror =
438 java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK);
439 _double_mirror =
440 java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK);
441 _byte_mirror =
442 java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK);
443 _bool_mirror =
444 java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK);
445 _char_mirror =
446 java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK);
|