< prev index next >

src/hotspot/share/cds/archiveBuilder.cpp

Print this page

  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "cds/archiveBuilder.hpp"
  27 #include "cds/archiveHeapWriter.hpp"
  28 #include "cds/archiveUtils.hpp"
  29 #include "cds/cppVtables.hpp"
  30 #include "cds/dumpAllocStats.hpp"
  31 #include "cds/heapShared.hpp"
  32 #include "cds/metaspaceShared.hpp"
  33 #include "classfile/classLoaderDataShared.hpp"
  34 #include "classfile/symbolTable.hpp"
  35 #include "classfile/systemDictionaryShared.hpp"
  36 #include "classfile/vmClasses.hpp"
  37 #include "interpreter/abstractInterpreter.hpp"
  38 #include "logging/log.hpp"
  39 #include "logging/logStream.hpp"
  40 #include "memory/allStatic.hpp"
  41 #include "memory/memRegion.hpp"
  42 #include "memory/resourceArea.hpp"

  43 #include "oops/instanceKlass.hpp"

  44 #include "oops/objArrayKlass.hpp"
  45 #include "oops/objArrayOop.inline.hpp"
  46 #include "oops/oopHandle.inline.hpp"
  47 #include "runtime/arguments.hpp"
  48 #include "runtime/globals_extension.hpp"
  49 #include "runtime/javaThread.hpp"
  50 #include "runtime/sharedRuntime.hpp"
  51 #include "utilities/align.hpp"
  52 #include "utilities/bitMap.inline.hpp"
  53 #include "utilities/formatBuffer.hpp"
  54 
  55 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
  56 
  57 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
  58   char* newtop = ArchiveBuilder::current()->_ro_region.top();
  59   ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
  60 }
  61 
  62 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
  63   _total_bytes = 0;

 203   GatherKlassesAndSymbols(ArchiveBuilder* builder) : _builder(builder) {}
 204 
 205   virtual bool do_unique_ref(Ref* ref, bool read_only) {
 206     return _builder->gather_klass_and_symbol(ref, read_only);
 207   }
 208 };
 209 
 210 bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool read_only) {
 211   if (ref->obj() == nullptr) {
 212     return false;
 213   }
 214   if (get_follow_mode(ref) != make_a_copy) {
 215     return false;
 216   }
 217   if (ref->msotype() == MetaspaceObj::ClassType) {
 218     Klass* klass = (Klass*)ref->obj();
 219     assert(klass->is_klass(), "must be");
 220     if (!is_excluded(klass)) {
 221       _klasses->append(klass);
 222     }
 223     // See RunTimeClassInfo::get_for()
 224     _estimated_metaspaceobj_bytes += align_up(BytesPerWord, SharedSpaceObjectAlignment);


 225   } else if (ref->msotype() == MetaspaceObj::SymbolType) {
 226     // Make sure the symbol won't be GC'ed while we are dumping the archive.
 227     Symbol* sym = (Symbol*)ref->obj();
 228     sym->increment_refcount();
 229     _symbols->append(sym);
 230   }
 231 
 232   int bytes = ref->size() * BytesPerWord;
 233   _estimated_metaspaceobj_bytes += align_up(bytes, SharedSpaceObjectAlignment);
 234 
 235   return true; // recurse
 236 }
 237 
 238 void ArchiveBuilder::gather_klasses_and_symbols() {
 239   ResourceMark rm;
 240   log_info(cds)("Gathering classes and symbols ... ");
 241   GatherKlassesAndSymbols doit(this);
 242   iterate_roots(&doit, /*is_relocating_pointers=*/false);
 243 #if INCLUDE_CDS_JAVA_HEAP
 244   if (is_dumping_full_module_graph()) {

 601 }
 602 
 603 void ArchiveBuilder::make_shallow_copies(DumpRegion *dump_region,
 604                                          const ArchiveBuilder::SourceObjList* src_objs) {
 605   for (int i = 0; i < src_objs->objs()->length(); i++) {
 606     make_shallow_copy(dump_region, src_objs->objs()->at(i));
 607   }
 608   log_info(cds)("done (%d objects)", src_objs->objs()->length());
 609 }
 610 
 611 void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* src_info) {
 612   MetaspaceClosure::Ref* ref = src_info->ref();
 613   address src = ref->obj();
 614   int bytes = src_info->size_in_bytes();
 615   char* dest;
 616   char* oldtop;
 617   char* newtop;
 618 
 619   oldtop = dump_region->top();
 620   if (ref->msotype() == MetaspaceObj::ClassType) {
 621     // Save a pointer immediate in front of an InstanceKlass, so
 622     // we can do a quick lookup from InstanceKlass* -> RunTimeClassInfo*
 623     // without building another hashtable. See RunTimeClassInfo::get_for()
 624     // in systemDictionaryShared.cpp.

 625     Klass* klass = (Klass*)src;
 626     if (klass->is_instance_klass()) {
 627       SystemDictionaryShared::validate_before_archiving(InstanceKlass::cast(klass));
 628       dump_region->allocate(sizeof(address));
 629     }



 630   }
 631   dest = dump_region->allocate(bytes);
 632   newtop = dump_region->top();
 633 
 634   memcpy(dest, src, bytes);
 635   {
 636     bool created;
 637     _buffered_to_src_table.put_if_absent((address)dest, src, &created);
 638     assert(created, "must be");
 639     if (_buffered_to_src_table.maybe_grow()) {
 640       log_info(cds, hashtables)("Expanded _buffered_to_src_table table to %d", _buffered_to_src_table.table_size());
 641     }
 642   }
 643 
 644   intptr_t* archived_vtable = CppVtables::get_archived_vtable(ref->msotype(), (address)dest);
 645   if (archived_vtable != nullptr) {
 646     *(address*)dest = (address)archived_vtable;
 647     ArchivePtrMarker::mark_pointer((address*)dest);
 648   }
 649 
 650   log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d", p2i(src), p2i(dest), bytes);

 651   src_info->set_buffered_addr((address)dest);
 652 
 653   _alloc_stats.record(ref->msotype(), int(newtop - oldtop), src_info->read_only());


 654 }
 655 
 656 address ArchiveBuilder::get_buffered_addr(address src_addr) const {
 657   SourceObjInfo* p = _src_obj_table.get(src_addr);
 658   assert(p != nullptr, "must be");
 659 
 660   return p->buffered_addr();
 661 }
 662 
 663 address ArchiveBuilder::get_source_addr(address buffered_addr) const {
 664   assert(is_in_buffer_space(buffered_addr), "must be");
 665   address* src_p = _buffered_to_src_table.get(buffered_addr);
 666   assert(src_p != nullptr && *src_p != nullptr, "must be");
 667   return *src_p;
 668 }
 669 
 670 void ArchiveBuilder::relocate_embedded_pointers(ArchiveBuilder::SourceObjList* src_objs) {
 671   for (int i = 0; i < src_objs->objs()->length(); i++) {
 672     src_objs->relocate(i, this);
 673   }

 730 }
 731 
 732 void ArchiveBuilder::make_klasses_shareable() {
 733   int num_instance_klasses = 0;
 734   int num_boot_klasses = 0;
 735   int num_platform_klasses = 0;
 736   int num_app_klasses = 0;
 737   int num_hidden_klasses = 0;
 738   int num_unlinked_klasses = 0;
 739   int num_unregistered_klasses = 0;
 740   int num_obj_array_klasses = 0;
 741   int num_type_array_klasses = 0;
 742 
 743   for (int i = 0; i < klasses()->length(); i++) {
 744     const char* type;
 745     const char* unlinked = "";
 746     const char* hidden = "";
 747     const char* generated = "";
 748     Klass* k = klasses()->at(i);
 749     k->remove_java_mirror();







 750     if (k->is_objArray_klass()) {
 751       // InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info
 752       // on their array classes.
 753       num_obj_array_klasses ++;
 754       type = "array";
 755     } else if (k->is_typeArray_klass()) {
 756       num_type_array_klasses ++;
 757       type = "array";
 758       k->remove_unshareable_info();
 759     } else {
 760       assert(k->is_instance_klass(), " must be");
 761       num_instance_klasses ++;
 762       InstanceKlass* ik = InstanceKlass::cast(k);
 763       if (DynamicDumpSharedSpaces) {
 764         // For static dump, class loader type are already set.
 765         ik->assign_class_loader_type();
 766       }
 767       if (ik->is_shared_boot_class()) {
 768         type = "boot";
 769         num_boot_klasses ++;

  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "cds/archiveBuilder.hpp"
  27 #include "cds/archiveHeapWriter.hpp"
  28 #include "cds/archiveUtils.hpp"
  29 #include "cds/cppVtables.hpp"
  30 #include "cds/dumpAllocStats.hpp"
  31 #include "cds/heapShared.hpp"
  32 #include "cds/metaspaceShared.hpp"
  33 #include "classfile/classLoaderDataShared.hpp"
  34 #include "classfile/symbolTable.hpp"
  35 #include "classfile/systemDictionaryShared.hpp"
  36 #include "classfile/vmClasses.hpp"
  37 #include "interpreter/abstractInterpreter.hpp"
  38 #include "logging/log.hpp"
  39 #include "logging/logStream.hpp"
  40 #include "memory/allStatic.hpp"
  41 #include "memory/memRegion.hpp"
  42 #include "memory/resourceArea.hpp"
  43 #include "oops/compressedKlass.inline.hpp"
  44 #include "oops/instanceKlass.hpp"
  45 #include "oops/klass.inline.hpp"
  46 #include "oops/objArrayKlass.hpp"
  47 #include "oops/objArrayOop.inline.hpp"
  48 #include "oops/oopHandle.inline.hpp"
  49 #include "runtime/arguments.hpp"
  50 #include "runtime/globals_extension.hpp"
  51 #include "runtime/javaThread.hpp"
  52 #include "runtime/sharedRuntime.hpp"
  53 #include "utilities/align.hpp"
  54 #include "utilities/bitMap.inline.hpp"
  55 #include "utilities/formatBuffer.hpp"
  56 
  57 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
  58 
  59 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
  60   char* newtop = ArchiveBuilder::current()->_ro_region.top();
  61   ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
  62 }
  63 
  64 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
  65   _total_bytes = 0;

 205   GatherKlassesAndSymbols(ArchiveBuilder* builder) : _builder(builder) {}
 206 
 207   virtual bool do_unique_ref(Ref* ref, bool read_only) {
 208     return _builder->gather_klass_and_symbol(ref, read_only);
 209   }
 210 };
 211 
 212 bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool read_only) {
 213   if (ref->obj() == nullptr) {
 214     return false;
 215   }
 216   if (get_follow_mode(ref) != make_a_copy) {
 217     return false;
 218   }
 219   if (ref->msotype() == MetaspaceObj::ClassType) {
 220     Klass* klass = (Klass*)ref->obj();
 221     assert(klass->is_klass(), "must be");
 222     if (!is_excluded(klass)) {
 223       _klasses->append(klass);
 224     }
 225     // See ArchiveBuilder::make_shallow_copies: make sure we have enough space for both maximum
 226     // Klass alignment as well as the RuntimeInfo* pointer we will embed in front of a Klass.
 227     _estimated_metaspaceobj_bytes += align_up(BytesPerWord, KlassAlignmentInBytes) +
 228         align_up(sizeof(void*), SharedSpaceObjectAlignment);
 229   } else if (ref->msotype() == MetaspaceObj::SymbolType) {
 230     // Make sure the symbol won't be GC'ed while we are dumping the archive.
 231     Symbol* sym = (Symbol*)ref->obj();
 232     sym->increment_refcount();
 233     _symbols->append(sym);
 234   }
 235 
 236   int bytes = ref->size() * BytesPerWord;
 237   _estimated_metaspaceobj_bytes += align_up(bytes, SharedSpaceObjectAlignment);
 238 
 239   return true; // recurse
 240 }
 241 
 242 void ArchiveBuilder::gather_klasses_and_symbols() {
 243   ResourceMark rm;
 244   log_info(cds)("Gathering classes and symbols ... ");
 245   GatherKlassesAndSymbols doit(this);
 246   iterate_roots(&doit, /*is_relocating_pointers=*/false);
 247 #if INCLUDE_CDS_JAVA_HEAP
 248   if (is_dumping_full_module_graph()) {

 605 }
 606 
 607 void ArchiveBuilder::make_shallow_copies(DumpRegion *dump_region,
 608                                          const ArchiveBuilder::SourceObjList* src_objs) {
 609   for (int i = 0; i < src_objs->objs()->length(); i++) {
 610     make_shallow_copy(dump_region, src_objs->objs()->at(i));
 611   }
 612   log_info(cds)("done (%d objects)", src_objs->objs()->length());
 613 }
 614 
 615 void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* src_info) {
 616   MetaspaceClosure::Ref* ref = src_info->ref();
 617   address src = ref->obj();
 618   int bytes = src_info->size_in_bytes();
 619   char* dest;
 620   char* oldtop;
 621   char* newtop;
 622 
 623   oldtop = dump_region->top();
 624   if (ref->msotype() == MetaspaceObj::ClassType) {
 625     // Reserve space for a pointer immediately in front of an InstanceKlass. That space will
 626     // later be used to store the RuntimeClassInfo* pointer directly in front of the archived
 627     // InstanceKlass, in order to have a quick lookup InstanceKlass* -> RunTimeClassInfo*
 628     // without building another hashtable. See RunTimeClassInfo::get_for()/::set_for() for
 629     // details.
 630     Klass* klass = (Klass*)src;
 631     if (klass->is_instance_klass()) {
 632       SystemDictionaryShared::validate_before_archiving(InstanceKlass::cast(klass));
 633       dump_region->allocate(sizeof(address));
 634     }
 635     dest = dump_region->allocate(bytes, KlassAlignmentInBytes);
 636   } else {
 637     dest = dump_region->allocate(bytes);
 638   }

 639   newtop = dump_region->top();
 640 
 641   memcpy(dest, src, bytes);
 642   {
 643     bool created;
 644     _buffered_to_src_table.put_if_absent((address)dest, src, &created);
 645     assert(created, "must be");
 646     if (_buffered_to_src_table.maybe_grow()) {
 647       log_info(cds, hashtables)("Expanded _buffered_to_src_table table to %d", _buffered_to_src_table.table_size());
 648     }
 649   }
 650 
 651   intptr_t* archived_vtable = CppVtables::get_archived_vtable(ref->msotype(), (address)dest);
 652   if (archived_vtable != nullptr) {
 653     *(address*)dest = (address)archived_vtable;
 654     ArchivePtrMarker::mark_pointer((address*)dest);
 655   }
 656 
 657   log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d (%s)", p2i(src), p2i(dest), bytes,
 658                  MetaspaceObj::type_name(ref->msotype()));
 659   src_info->set_buffered_addr((address)dest);
 660 
 661   _alloc_stats.record(ref->msotype(), int(newtop - oldtop), src_info->read_only());
 662 
 663   DEBUG_ONLY(_alloc_stats.verify((int)dump_region->used(), src_info->read_only()));
 664 }
 665 
 666 address ArchiveBuilder::get_buffered_addr(address src_addr) const {
 667   SourceObjInfo* p = _src_obj_table.get(src_addr);
 668   assert(p != nullptr, "must be");
 669 
 670   return p->buffered_addr();
 671 }
 672 
 673 address ArchiveBuilder::get_source_addr(address buffered_addr) const {
 674   assert(is_in_buffer_space(buffered_addr), "must be");
 675   address* src_p = _buffered_to_src_table.get(buffered_addr);
 676   assert(src_p != nullptr && *src_p != nullptr, "must be");
 677   return *src_p;
 678 }
 679 
 680 void ArchiveBuilder::relocate_embedded_pointers(ArchiveBuilder::SourceObjList* src_objs) {
 681   for (int i = 0; i < src_objs->objs()->length(); i++) {
 682     src_objs->relocate(i, this);
 683   }

 740 }
 741 
 742 void ArchiveBuilder::make_klasses_shareable() {
 743   int num_instance_klasses = 0;
 744   int num_boot_klasses = 0;
 745   int num_platform_klasses = 0;
 746   int num_app_klasses = 0;
 747   int num_hidden_klasses = 0;
 748   int num_unlinked_klasses = 0;
 749   int num_unregistered_klasses = 0;
 750   int num_obj_array_klasses = 0;
 751   int num_type_array_klasses = 0;
 752 
 753   for (int i = 0; i < klasses()->length(); i++) {
 754     const char* type;
 755     const char* unlinked = "";
 756     const char* hidden = "";
 757     const char* generated = "";
 758     Klass* k = klasses()->at(i);
 759     k->remove_java_mirror();
 760 #ifdef _LP64
 761     if (UseCompactObjectHeaders) {
 762       Klass* requested_k = to_requested(k);
 763       narrowKlass nk = CompressedKlassPointers::encode_not_null(requested_k, _requested_static_archive_bottom);
 764       k->set_prototype_header(markWord::prototype().set_narrow_klass(nk));
 765     }
 766 #endif //_LP64
 767     if (k->is_objArray_klass()) {
 768       // InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info
 769       // on their array classes.
 770       num_obj_array_klasses ++;
 771       type = "array";
 772     } else if (k->is_typeArray_klass()) {
 773       num_type_array_klasses ++;
 774       type = "array";
 775       k->remove_unshareable_info();
 776     } else {
 777       assert(k->is_instance_klass(), " must be");
 778       num_instance_klasses ++;
 779       InstanceKlass* ik = InstanceKlass::cast(k);
 780       if (DynamicDumpSharedSpaces) {
 781         // For static dump, class loader type are already set.
 782         ik->assign_class_loader_type();
 783       }
 784       if (ik->is_shared_boot_class()) {
 785         type = "boot";
 786         num_boot_klasses ++;
< prev index next >