349
350 dynamic_info->open_as_output();
351 ArchiveHeapInfo no_heap_for_dynamic_dump;
352 ArchiveBuilder::write_archive(dynamic_info, &no_heap_for_dynamic_dump);
353
354 address base = _requested_dynamic_archive_bottom;
355 address top = _requested_dynamic_archive_top;
356 size_t file_size = pointer_delta(top, base, sizeof(char));
357
358 log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT
359 " [" UINT32_FORMAT " bytes header, %zu bytes total]",
360 p2i(base), p2i(top), _header->header_size(), file_size);
361
362 log_info(cds, dynamic)("%d klasses; %d symbols", klasses()->length(), symbols()->length());
363 }
364
365 void DynamicArchiveBuilder::gather_array_klasses() {
366 for (int i = 0; i < klasses()->length(); i++) {
367 if (klasses()->at(i)->is_objArray_klass()) {
368 ObjArrayKlass* oak = ObjArrayKlass::cast(klasses()->at(i));
369 Klass* elem = oak->element_klass();
370 if (MetaspaceShared::is_shared_static(elem)) {
371 // Only capture the array klass whose element_klass is in the static archive.
372 // During run time, setup (see DynamicArchive::setup_array_klasses()) is needed
373 // so that the element_klass can find its array klasses from the dynamic archive.
374 DynamicArchive::append_array_klass(oak);
375 } else {
376 // The element_klass and its array klasses are in the same archive.
377 assert(!MetaspaceShared::is_shared_static(oak),
378 "we should not gather klasses that are already in the static archive");
379 }
380 }
381 }
382 log_debug(aot)("Total array klasses gathered for dynamic archive: %d", DynamicArchive::num_array_klasses());
383 }
384
385 class VM_PopulateDynamicDumpSharedSpace: public VM_Heap_Sync_Operation {
386 DynamicArchiveBuilder _builder;
387 public:
388 VM_PopulateDynamicDumpSharedSpace(const char* archive_name)
419 assert(CDSConfig::is_dumping_dynamic_archive(), "sanity");
420 if (_array_klasses != nullptr) {
421 ArchiveBuilder* builder = ArchiveBuilder::current();
422 int num_array_klasses = _array_klasses->length();
423 _dynamic_archive_array_klasses =
424 ArchiveBuilder::new_ro_array<ObjArrayKlass*>(num_array_klasses);
425 for (int i = 0; i < num_array_klasses; i++) {
426 builder->write_pointer_in_buffer(_dynamic_archive_array_klasses->adr_at(i), _array_klasses->at(i));
427 }
428 }
429 }
430
431 void DynamicArchive::setup_array_klasses() {
432 if (_dynamic_archive_array_klasses != nullptr) {
433 for (int i = 0; i < _dynamic_archive_array_klasses->length(); i++) {
434 ObjArrayKlass* oak = _dynamic_archive_array_klasses->at(i);
435 assert(!oak->is_typeArray_klass(), "all type array classes must be in static archive");
436
437 Klass* elm = oak->element_klass();
438 assert(MetaspaceShared::is_shared_static((void*)elm), "must be");
439
440 if (elm->is_instance_klass()) {
441 assert(InstanceKlass::cast(elm)->array_klasses() == nullptr, "must be");
442 InstanceKlass::cast(elm)->set_array_klasses(oak);
443 } else {
444 assert(elm->is_array_klass(), "sanity");
445 assert(ArrayKlass::cast(elm)->higher_dimension() == nullptr, "must be");
446 ArrayKlass::cast(elm)->set_higher_dimension(oak);
447 }
448 }
449 log_debug(aot)("Total array klasses read from dynamic archive: %d", _dynamic_archive_array_klasses->length());
450 }
451 }
452
453 void DynamicArchive::serialize_array_klasses(SerializeClosure* soc) {
454 soc->do_ptr(&_dynamic_archive_array_klasses);
455 }
456
457 void DynamicArchive::make_array_klasses_shareable() {
458 if (_array_klasses != nullptr) {
459 int num_array_klasses = _array_klasses->length();
460 for (int i = 0; i < num_array_klasses; i++) {
461 ObjArrayKlass* k = ArchiveBuilder::current()->get_buffered_addr(_array_klasses->at(i));
462 k->remove_unshareable_info();
463 }
464 }
465 }
466
|
349
350 dynamic_info->open_as_output();
351 ArchiveHeapInfo no_heap_for_dynamic_dump;
352 ArchiveBuilder::write_archive(dynamic_info, &no_heap_for_dynamic_dump);
353
354 address base = _requested_dynamic_archive_bottom;
355 address top = _requested_dynamic_archive_top;
356 size_t file_size = pointer_delta(top, base, sizeof(char));
357
358 log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT
359 " [" UINT32_FORMAT " bytes header, %zu bytes total]",
360 p2i(base), p2i(top), _header->header_size(), file_size);
361
362 log_info(cds, dynamic)("%d klasses; %d symbols", klasses()->length(), symbols()->length());
363 }
364
365 void DynamicArchiveBuilder::gather_array_klasses() {
366 for (int i = 0; i < klasses()->length(); i++) {
367 if (klasses()->at(i)->is_objArray_klass()) {
368 ObjArrayKlass* oak = ObjArrayKlass::cast(klasses()->at(i));
369 if (oak->is_refined_objArray_klass()) {
370 oak = ObjArrayKlass::cast(oak->super());
371 }
372 Klass* elem = oak->element_klass();
373 if (MetaspaceShared::is_shared_static(elem)) {
374 // Only capture the array klass whose element_klass is in the static archive.
375 // During run time, setup (see DynamicArchive::setup_array_klasses()) is needed
376 // so that the element_klass can find its array klasses from the dynamic archive.
377 DynamicArchive::append_array_klass(oak);
378 } else {
379 // The element_klass and its array klasses are in the same archive.
380 assert(!MetaspaceShared::is_shared_static(oak),
381 "we should not gather klasses that are already in the static archive");
382 }
383 }
384 }
385 log_debug(aot)("Total array klasses gathered for dynamic archive: %d", DynamicArchive::num_array_klasses());
386 }
387
388 class VM_PopulateDynamicDumpSharedSpace: public VM_Heap_Sync_Operation {
389 DynamicArchiveBuilder _builder;
390 public:
391 VM_PopulateDynamicDumpSharedSpace(const char* archive_name)
422 assert(CDSConfig::is_dumping_dynamic_archive(), "sanity");
423 if (_array_klasses != nullptr) {
424 ArchiveBuilder* builder = ArchiveBuilder::current();
425 int num_array_klasses = _array_klasses->length();
426 _dynamic_archive_array_klasses =
427 ArchiveBuilder::new_ro_array<ObjArrayKlass*>(num_array_klasses);
428 for (int i = 0; i < num_array_klasses; i++) {
429 builder->write_pointer_in_buffer(_dynamic_archive_array_klasses->adr_at(i), _array_klasses->at(i));
430 }
431 }
432 }
433
434 void DynamicArchive::setup_array_klasses() {
435 if (_dynamic_archive_array_klasses != nullptr) {
436 for (int i = 0; i < _dynamic_archive_array_klasses->length(); i++) {
437 ObjArrayKlass* oak = _dynamic_archive_array_klasses->at(i);
438 assert(!oak->is_typeArray_klass(), "all type array classes must be in static archive");
439
440 Klass* elm = oak->element_klass();
441 assert(MetaspaceShared::is_shared_static((void*)elm), "must be");
442 // Higher dimension may have been set when doing setup on ObjArrayKlass
443 if (!oak->is_refined_objArray_klass()) {
444 if (elm->is_instance_klass()) {
445 assert(InstanceKlass::cast(elm)->array_klasses() == nullptr, "must be");
446 InstanceKlass::cast(elm)->set_array_klasses(oak);
447 } else {
448 assert(elm->is_array_klass(), "sanity");
449 assert(ArrayKlass::cast(elm)->higher_dimension() == nullptr, "must be");
450 ArrayKlass::cast(elm)->set_higher_dimension(oak);
451 }
452 }
453 }
454 log_debug(aot)("Total array klasses read from dynamic archive: %d", _dynamic_archive_array_klasses->length());
455 }
456 }
457
458 void DynamicArchive::serialize_array_klasses(SerializeClosure* soc) {
459 soc->do_ptr(&_dynamic_archive_array_klasses);
460 }
461
462 void DynamicArchive::make_array_klasses_shareable() {
463 if (_array_klasses != nullptr) {
464 int num_array_klasses = _array_klasses->length();
465 for (int i = 0; i < num_array_klasses; i++) {
466 ObjArrayKlass* k = ArchiveBuilder::current()->get_buffered_addr(_array_klasses->at(i));
467 k->remove_unshareable_info();
468 }
469 }
470 }
471
|