jdk-sandbox: comparison hotspot/src/share/vm/memory/metaspaceShared.cpp

equal deleted inserted replaced

-:057f21a10f5f
+:7dad333205cd
 #include "classfile/symbolTable.hpp"
 #include "classfile/stringTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/systemDictionaryShared.hpp"
 #include "code/codeCache.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc/g1/g1Allocator.inline.hpp"
+#include "gc/g1/g1CollectedHeap.hpp"
+#include "gc/g1/g1SATBCardTableModRefBS.hpp"
+#endif
 #include "gc/shared/gcLocker.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/bytecodes.hpp"
 #include "logging/log.hpp"
 #include "logging/logMessage.hpp"
 VirtualSpace MetaspaceShared::_shared_vs;
 MetaspaceSharedStats MetaspaceShared::_stats;
 bool MetaspaceShared::_has_error_classes;
 bool MetaspaceShared::_archive_loading_failed = false;
 bool MetaspaceShared::_remapped_readwrite = false;
+bool MetaspaceShared::_open_archive_heap_region_mapped = false;
 address MetaspaceShared::_cds_i2i_entry_code_buffers = NULL;
 size_t MetaspaceShared::_cds_i2i_entry_code_buffers_size = 0;
 size_t MetaspaceShared::_core_spaces_size = 0;
 // The CDS archive is divided into the following regions:
-//     mc - misc code (the method entry trampolines)
+//     mc  - misc code (the method entry trampolines)
-//     rw - read-write metadata
+//     rw  - read-write metadata
-//     ro - read-only metadata and read-only tables
+//     ro  - read-only metadata and read-only tables
-//     md - misc data (the c++ vtables)
+//     md  - misc data (the c++ vtables)
-//     od - optional data (original class files)
+//     od  - optional data (original class files)
 //
-//     s0 - shared strings #0
+//     s0  - shared strings(closed archive heap space) #0
-//     s1 - shared strings #1 (may be empty)
+//     s1  - shared strings(closed archive heap space) #1 (may be empty)
+//     oa0 - open archive heap space #0
+//     oa1 - open archive heap space #1 (may be empty)
 //
-// Except for the s0/s1 regions, the other 5 regions are linearly allocated, starting from
+// The mc, rw, ro, md and od regions are linearly allocated, starting from
 // SharedBaseAddress, in the order of mc->rw->ro->md->od. The size of these 5 regions
 // are page-aligned, and there's no gap between any consecutive regions.
 //
 // These 5 regions are populated in the following steps:
 // [1] All classes are loaded in MetaspaceShared::preload_classes(). All metadata are
 // [4] SymbolTable, StringTable, SystemDictionary, and a few other read-only data
 //     are copied into the ro region as read-only tables.
 // [5] C++ vtables are copied into the md region.
 // [6] Original class files are copied into the od region.
 //
-// The s0/s1 regions are populated inside MetaspaceShared::dump_string_and_symbols. Their
+// The s0/s1 and oa0/oa1 regions are populated inside MetaspaceShared::dump_java_heap_objects.
-// layout is independent of the other 5 regions.
+// Their layout is independent of the other 5 regions.
 class DumpRegion {
 private:
 const char* _name;
 char* _base;
 bool contains(char* p) {
 return base() <= p && p < top();
 }
 };
 DumpRegion _mc_region("mc"), _ro_region("ro"), _rw_region("rw"), _md_region("md"), _od_region("od");
-DumpRegion _s0_region("s0"), _s1_region("s1");
+size_t _total_string_region_size = 0, _total_open_archive_region_size = 0;
 char* MetaspaceShared::misc_code_space_alloc(size_t num_bytes) {
 return _mc_region.allocate(num_bytes);
 }
 // Populate the shared space.
 class VM_PopulateDumpSharedSpace: public VM_Operation {
 private:
 GrowableArray<MemRegion> *_string_regions;
+GrowableArray<MemRegion> *_open_archive_heap_regions;
-void dump_string_and_symbols();
+void dump_java_heap_objects() NOT_CDS_JAVA_HEAP_RETURN;
+void dump_symbols();
 char* dump_read_only_tables();
 void print_region_stats();
+void print_heap_region_stats(GrowableArray<MemRegion> *heap_mem,
+const char *name, const size_t total_size);
 public:
 VMOp_Type type() const { return VMOp_PopulateDumpSharedSpace; }
 void doit();   // outline because gdb sucks
 static void write_region(FileMapInfo* mapinfo, int region, DumpRegion* space, bool read_only,  bool allow_exec);
 // cleanup
 _ssc = NULL;
 }
 // We must relocate the System::_well_known_klasses only after we have copied the
-// strings in during dump_string_and_symbols(): during the string copy, we operate on old
+// java objects in during dump_java_heap_objects(): during the object copy, we operate on
-// String objects which assert that their klass is the old
+// old objects which assert that their klass is the original klass.
-// SystemDictionary::String_klass().
 static void relocate_well_known_klasses() {
 {
 tty->print_cr("Relocating SystemDictionary::_well_known_klasses[] ... ");
 ResourceMark rm;
 RefRelocator ext_reloc;
 void VM_PopulateDumpSharedSpace::write_region(FileMapInfo* mapinfo, int region_idx,
 DumpRegion* dump_region, bool read_only,  bool allow_exec) {
 mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
 }
-void VM_PopulateDumpSharedSpace::dump_string_and_symbols() {
+void VM_PopulateDumpSharedSpace::dump_symbols() {
-tty->print_cr("Dumping string and symbol tables ...");
+tty->print_cr("Dumping symbol table ...");
 NOT_PRODUCT(SymbolTable::verify());
-NOT_PRODUCT(StringTable::verify());
 SymbolTable::write_to_archive();
-// The string space has maximum two regions. See FileMapInfo::write_string_regions() for details.
-_string_regions = new GrowableArray<MemRegion>(2);
-StringTable::write_to_archive(_string_regions);
 }
 char* VM_PopulateDumpSharedSpace::dump_read_only_tables() {
 char* oldtop = _ro_region.top();
 // Reorder the system dictionary. Moving the symbols affects
 tty->print_cr("    instance classes   = %5d", num_inst);
 tty->print_cr("    obj array classes  = %5d", num_obj_array);
 tty->print_cr("    type array classes = %5d", num_type_array);
 }
 // Ensure the ConstMethods won't be modified at run-time
 tty->print("Updating ConstMethods ... ");
 rewrite_nofast_bytecodes_and_calculate_fingerprints();
 tty->print_cr("done. ");
 tty->print_cr("done. ");
 ArchiveCompactor::initialize();
 ArchiveCompactor::copy_and_compact();
-dump_string_and_symbols();
+dump_symbols();
+// Dump supported java heap objects
+_string_regions = NULL;
+_open_archive_heap_regions = NULL;
+dump_java_heap_objects();
 ArchiveCompactor::relocate_well_known_klasses();
 char* read_only_tables_start = dump_read_only_tables();
 _ro_region.pack(&_md_region);
 mapinfo->set_read_only_tables_start(read_only_tables_start);
 mapinfo->set_misc_data_patching_start(vtbl_list);
 mapinfo->set_cds_i2i_entry_code_buffers(MetaspaceShared::cds_i2i_entry_code_buffers());
 mapinfo->set_cds_i2i_entry_code_buffers_size(MetaspaceShared::cds_i2i_entry_code_buffers_size());
 mapinfo->set_core_spaces_size(core_spaces_size);
-char* s0_start, *s0_top, *s0_end;
-char* s1_start, *s1_top, *s1_end;
 for (int pass=1; pass<=2; pass++) {
 if (pass == 1) {
 // The first pass doesn't actually write the data to disk. All it
 // does is to update the fields in the mapinfo->_header.
 write_region(mapinfo, MetaspaceShared::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
 write_region(mapinfo, MetaspaceShared::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
 write_region(mapinfo, MetaspaceShared::md, &_md_region, /*read_only=*/false,/*allow_exec=*/false);
 write_region(mapinfo, MetaspaceShared::od, &_od_region, /*read_only=*/true, /*allow_exec=*/false);
-mapinfo->write_string_regions(_string_regions,
+_total_string_region_size = mapinfo->write_archive_heap_regions(
-&s0_start, &s0_top, &s0_end,
+_string_regions,
-&s1_start, &s1_top, &s1_end);
+MetaspaceShared::first_string,
+MetaspaceShared::max_strings);
+_total_open_archive_region_size = mapinfo->write_archive_heap_regions(
+_open_archive_heap_regions,
+MetaspaceShared::first_open_archive_heap_region,
+MetaspaceShared::max_open_archive_heap_region);
 }
 mapinfo->close();
 // Restore the vtable in case we invoke any virtual methods.
 MetaspaceShared::clone_cpp_vtables((intptr_t*)vtbl_list);
-_s0_region.init(s0_start, s0_top, s0_end);
-_s1_region.init(s1_start, s1_top, s1_end);
 print_region_stats();
 if (log_is_enabled(Info, cds)) {
 ArchiveCompactor::alloc_stats()->print_stats(int(_ro_region.used()), int(_rw_region.used()),
 int(_mc_region.used()), int(_md_region.used()));
 }
 }
 void VM_PopulateDumpSharedSpace::print_region_stats() {
 // Print statistics of all the regions
-const size_t total_reserved = _ro_region.reserved() + _rw_region.reserved() +
+const size_t total_reserved = _ro_region.reserved()  + _rw_region.reserved() +
-_mc_region.reserved() + _md_region.reserved() +
+_mc_region.reserved()  + _md_region.reserved() +
-_od_region.reserved() +
+_od_region.reserved()  +
-_s0_region.reserved() + _s1_region.reserved();
+_total_string_region_size +
-const size_t total_bytes = _ro_region.used() + _rw_region.used() +
+_total_open_archive_region_size;
-_mc_region.used() + _md_region.used() +
+const size_t total_bytes = _ro_region.used()  + _rw_region.used() +
-_od_region.used() +
+_mc_region.used()  + _md_region.used() +
-_s0_region.used() + _s1_region.used();
+_od_region.used()  +
+_total_string_region_size +
+_total_open_archive_region_size;
 const double total_u_perc = total_bytes / double(total_reserved) * 100.0;
 _mc_region.print(total_reserved);
 _rw_region.print(total_reserved);
 _ro_region.print(total_reserved);
 _md_region.print(total_reserved);
 _od_region.print(total_reserved);
-_s0_region.print(total_reserved);
+print_heap_region_stats(_string_regions, "st", total_reserved);
-_s1_region.print(total_reserved);
+print_heap_region_stats(_open_archive_heap_regions, "oa", total_reserved);
 tty->print_cr("total   : " SIZE_FORMAT_W(9) " [100.0%% of total] out of " SIZE_FORMAT_W(9) " bytes [%5.1f%% used]",
 total_bytes, total_reserved, total_u_perc);
 }
+void VM_PopulateDumpSharedSpace::print_heap_region_stats(GrowableArray<MemRegion> *heap_mem,
+const char *name, const size_t total_size) {
+int arr_len = heap_mem == NULL ? 0 : heap_mem->length();
+for (int i = 0; i < arr_len; i++) {
+char* start = (char*)heap_mem->at(i).start();
+size_t size = heap_mem->at(i).byte_size();
+char* top = start + size;
+tty->print_cr("%s%d space: " SIZE_FORMAT_W(9) " [ %4.1f%% of total] out of " SIZE_FORMAT_W(9) " bytes [100%% used] at " INTPTR_FORMAT,
+name, i, size, size/double(total_size)*100.0, size, p2i(start));
+}
+}
 // Update a Java object to point its Klass* to the new location after
 // shared archive has been compacted.
 void MetaspaceShared::relocate_klass_ptr(oop o) {
 assert(DumpSharedSpaces, "sanity");
 // Link the class to cause the bytecodes to be rewritten and the
 // cpcache to be created. Class verification is done according
 // to -Xverify setting.
 _made_progress |= MetaspaceShared::try_link_class(ik, THREAD);
 guarantee(!HAS_PENDING_EXCEPTION, "exception in link_class");
+ik->constants()->resolve_class_constants(THREAD);
 }
 }
 };
 class CheckSharedClassesClosure : public KlassClosure {
 } else {
 return false;
 }
 }
+#if INCLUDE_CDS_JAVA_HEAP
+void VM_PopulateDumpSharedSpace::dump_java_heap_objects() {
+if (!MetaspaceShared::is_heap_object_archiving_allowed()) {
+if (log_is_enabled(Info, cds)) {
+log_info(cds)(
+"Archived java heap is not supported as UseG1GC, "
+"UseCompressedOops and UseCompressedClassPointers are required."
+"Current settings: UseG1GC=%s, UseCompressedOops=%s, UseCompressedClassPointers=%s.",
+BOOL_TO_STR(UseG1GC), BOOL_TO_STR(UseCompressedOops),
+BOOL_TO_STR(UseCompressedClassPointers));
+}
+return;
+}
+{
+NoSafepointVerifier nsv;
+// Cache for recording where the archived objects are copied to
+MetaspaceShared::create_archive_object_cache();
+tty->print_cr("Dumping String objects to closed archive heap region ...");
+NOT_PRODUCT(StringTable::verify());
+// The string space has maximum two regions. See FileMapInfo::write_archive_heap_regions() for details.
+_string_regions = new GrowableArray<MemRegion>(2);
+StringTable::write_to_archive(_string_regions);
+tty->print_cr("Dumping objects to open archive heap region ...");
+_open_archive_heap_regions = new GrowableArray<MemRegion>(2);
+MetaspaceShared::dump_open_archive_heap_objects(_open_archive_heap_regions);
+}
+G1HeapVerifier::verify_archive_regions();
+}
+void MetaspaceShared::dump_open_archive_heap_objects(
+GrowableArray<MemRegion> * open_archive) {
+assert(UseG1GC, "Only support G1 GC");
+assert(UseCompressedOops && UseCompressedClassPointers,
+"Only support UseCompressedOops and UseCompressedClassPointers enabled");
+Thread* THREAD = Thread::current();
+G1CollectedHeap::heap()->begin_archive_alloc_range(true /* open */);
+MetaspaceShared::archive_resolved_constants(THREAD);
+G1CollectedHeap::heap()->end_archive_alloc_range(open_archive,
+os::vm_allocation_granularity());
+}
+MetaspaceShared::ArchivedObjectCache* MetaspaceShared::_archive_object_cache = NULL;
+oop MetaspaceShared::archive_heap_object(oop obj, Thread* THREAD) {
+assert(DumpSharedSpaces, "dump-time only");
+ArchivedObjectCache* cache = MetaspaceShared::archive_object_cache();
+oop* p = cache->get(obj);
+if (p != NULL) {
+// already archived
+return *p;
+}
+int len = obj->size();
+if (G1CollectedHeap::heap()->is_archive_alloc_too_large(len)) {
+return NULL;
+}
+int hash = obj->identity_hash();
+oop archived_oop = (oop)G1CollectedHeap::heap()->archive_mem_allocate(len);
+if (archived_oop != NULL) {
+Copy::aligned_disjoint_words((HeapWord*)obj, (HeapWord*)archived_oop, len);
+relocate_klass_ptr(archived_oop);
+cache->put(obj, archived_oop);
+}
+return archived_oop;
+}
+void MetaspaceShared::archive_resolved_constants(Thread* THREAD) {
+int i;
+for (i = 0; i < _global_klass_objects->length(); i++) {
+Klass* k = _global_klass_objects->at(i);
+if (k->is_instance_klass()) {
+InstanceKlass* ik = InstanceKlass::cast(k);
+ik->constants()->archive_resolved_references(THREAD);
+}
+}
+}
+void MetaspaceShared::fixup_mapped_heap_regions() {
+FileMapInfo *mapinfo = FileMapInfo::current_info();
+mapinfo->fixup_mapped_heap_regions();
+}
+#endif // INCLUDE_CDS_JAVA_HEAP
 // Closure for serializing initialization data in from a data area
 // (ptr_array) read from the shared file.
 class ReadClosure : public SerializeClosure {
 private:
 vm_exit(0);
 }
 }
 }
-void MetaspaceShared::fixup_shared_string_regions() {
-FileMapInfo *mapinfo = FileMapInfo::current_info();
-mapinfo->fixup_string_regions();
-}
 // JVM/TI RedefineClasses() support:
 bool MetaspaceShared::remap_shared_readonly_as_readwrite() {
 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
 if (UseSharedSpaces) {

changeset 46810	7dad333205cd
parent 46746	ea379ebb9447
child 46989	119e1e88cf15