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

equal deleted inserted replaced

-:25048be67f4a
+:187c84a5efe1
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/bytecodes.hpp"
 #include "logging/log.hpp"
 #include "logging/logMessage.hpp"
 #include "memory/filemap.hpp"
-#include "memory/heapShared.hpp"
+#include "memory/heapShared.inline.hpp"
 #include "memory/metaspace.hpp"
 #include "memory/metaspaceClosure.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/compressedOops.inline.hpp"
 #include "runtime/signature.hpp"
 #include "runtime/timerTrace.hpp"
 #include "runtime/vmThread.hpp"
 #include "runtime/vm_operations.hpp"
 #include "utilities/align.hpp"
+#include "utilities/bitMap.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/hashtable.inline.hpp"
 #if INCLUDE_G1GC
 #include "gc/g1/g1Allocator.inline.hpp"
 #include "gc/g1/g1CollectedHeap.hpp"
 // initialization fails, shared spaces [UseSharedSpaces] are
 // disabled and the file is closed.
 // Map in spaces now also
 if (mapinfo->initialize() && map_shared_spaces(mapinfo)) {
 size_t cds_total = core_spaces_size();
-cds_address = (address)mapinfo->header()->region_addr(0);
+cds_address = (address)mapinfo->region_addr(0);
 #ifdef _LP64
 if (Metaspace::using_class_space()) {
 char* cds_end = (char*)(cds_address + cds_total);
 cds_end = (char *)align_up(cds_end, Metaspace::reserve_alignment());
 // If UseCompressedClassPointers is set then allocate the metaspace area
 Universe::set_narrow_klass_shift(LogKlassAlignmentInBytes);
 // Set the range of klass addresses to 4GB.
 Universe::set_narrow_klass_range(cds_total);
 Metaspace::initialize_class_space(tmp_class_space);
-tty->print_cr("narrow_klass_base = " PTR_FORMAT ", narrow_klass_shift = %d",
+log_info(cds)("narrow_klass_base = " PTR_FORMAT ", narrow_klass_shift = %d",
 p2i(Universe::narrow_klass_base()), Universe::narrow_klass_shift());
-tty->print_cr("Allocated temporary class space: " SIZE_FORMAT " bytes at " PTR_FORMAT,
+log_info(cds)("Allocated temporary class space: " SIZE_FORMAT " bytes at " PTR_FORMAT,
 CompressedClassSpaceSize, p2i(tmp_class_space.base()));
 #endif
 // Start with 0 committed bytes. The memory will be committed as needed by
 // MetaspaceShared::commit_shared_space_to().
 SymbolTable::serialize(soc);
 StringTable::serialize(soc);
 soc->do_tag(--tag);
 JavaClasses::serialize_offsets(soc);
+InstanceMirrorKlass::serialize_offsets(soc);
 soc->do_tag(--tag);
 soc->do_tag(666);
 }
 class VM_PopulateDumpSharedSpace: public VM_Operation {
 private:
 GrowableArray<MemRegion> *_closed_archive_heap_regions;
 GrowableArray<MemRegion> *_open_archive_heap_regions;
+GrowableArray<ArchiveHeapOopmapInfo> *_closed_archive_heap_oopmaps;
+GrowableArray<ArchiveHeapOopmapInfo> *_open_archive_heap_oopmaps;
 void dump_java_heap_objects() NOT_CDS_JAVA_HEAP_RETURN;
+void dump_archive_heap_oopmaps() NOT_CDS_JAVA_HEAP_RETURN;
+void dump_archive_heap_oopmaps(GrowableArray<MemRegion>* regions,
+GrowableArray<ArchiveHeapOopmapInfo>* oopmaps);
 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);
 HeapShared::write_archived_subgraph_infos();
 // Write the other data to the output array.
 WriteClosure wc(&_ro_region);
 MetaspaceShared::serialize(&wc);
+// Write the bitmaps for patching the archive heap regions
+dump_archive_heap_oopmaps();
 char* newtop = _ro_region.top();
 ArchiveCompactor::alloc_stats()->record_other_type(int(newtop - oldtop), true);
 return buckets_top;
 }
 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);
 _total_string_region_size = mapinfo->write_archive_heap_regions(
 _closed_archive_heap_regions,
+_closed_archive_heap_oopmaps,
 MetaspaceShared::first_string,
 MetaspaceShared::max_strings);
 _total_open_archive_region_size = mapinfo->write_archive_heap_regions(
 _open_archive_heap_regions,
+_open_archive_heap_oopmaps,
 MetaspaceShared::first_open_archive_heap_region,
 MetaspaceShared::max_open_archive_heap_region);
 }
 mapinfo->close();
 }
 G1HeapVerifier::verify_archive_regions();
 }
+void VM_PopulateDumpSharedSpace::dump_archive_heap_oopmaps() {
+if (MetaspaceShared::is_heap_object_archiving_allowed()) {
+_closed_archive_heap_oopmaps = new GrowableArray<ArchiveHeapOopmapInfo>(2);
+dump_archive_heap_oopmaps(_closed_archive_heap_regions, _closed_archive_heap_oopmaps);
+_open_archive_heap_oopmaps = new GrowableArray<ArchiveHeapOopmapInfo>(2);
+dump_archive_heap_oopmaps(_open_archive_heap_regions, _open_archive_heap_oopmaps);
+}
+}
+void VM_PopulateDumpSharedSpace::dump_archive_heap_oopmaps(GrowableArray<MemRegion>* regions,
+GrowableArray<ArchiveHeapOopmapInfo>* oopmaps) {
+for (int i=0; i<regions->length(); i++) {
+ResourceBitMap oopmap = HeapShared::calculate_oopmap(regions->at(i));
+size_t size_in_bits = oopmap.size();
+size_t size_in_bytes = oopmap.size_in_bytes();
+uintptr_t* buffer = (uintptr_t*)_ro_region.allocate(size_in_bytes, sizeof(intptr_t));
+oopmap.write_to(buffer, size_in_bytes);
+log_info(cds)("Oopmap = " INTPTR_FORMAT " (" SIZE_FORMAT_W(6) " bytes) for heap region "
+INTPTR_FORMAT " (" SIZE_FORMAT_W(8) " bytes)",
+p2i(buffer), size_in_bytes,
+p2i(regions->at(i).start()), regions->at(i).byte_size());
+ArchiveHeapOopmapInfo info;
+info._oopmap = (address)buffer;
+info._oopmap_size_in_bits = size_in_bits;
+oopmaps->append(info);
+}
+}
 void MetaspaceShared::dump_closed_archive_heap_objects(
 GrowableArray<MemRegion> * closed_archive) {
 assert(is_heap_object_archiving_allowed(), "Cannot dump java heap objects");
 Thread* THREAD = Thread::current();
 vm_exit(1);
 }
 return archived_oop;
 }
-oop MetaspaceShared::materialize_archived_object(oop obj) {
+oop MetaspaceShared::materialize_archived_object(narrowOop v) {
-if (obj != NULL) {
+if (!CompressedOops::is_null(v)) {
+oop obj = HeapShared::decode_with_archived_oop_encoding_mode(v);
 return G1CollectedHeap::heap()->materialize_archived_object(obj);
 }
 return NULL;
 }
 } else {
 assert(MetaspaceShared::is_heap_object_archiving_allowed(),
 "Archived heap object is not allowed");
 assert(MetaspaceShared::open_archive_heap_region_mapped(),
 "Open archive heap region is not mapped");
-*p = CompressedOops::decode_not_null(o);
+*p = HeapShared::decode_with_archived_oop_encoding_mode(o);
 }
 }
 void do_region(u_char* start, size_t size) {
 assert((intptr_t)start % sizeof(intptr_t) == 0, "bad alignment");
 if (UseSharedSpaces && is_in_shared_region(addr, MetaspaceShared::mc)) {
 return true;
 }
 return false;
 }
-void MetaspaceShared::print_shared_spaces() {
-if (UseSharedSpaces) {
-FileMapInfo::current_info()->print_shared_spaces();
-}
-}
 // Map shared spaces at requested addresses and return if succeeded.
 bool MetaspaceShared::map_shared_spaces(FileMapInfo* mapinfo) {
 size_t image_alignment = mapinfo->alignment();
 serialize(&rc);
 // Initialize the run-time symbol table.
 SymbolTable::create_table();
+mapinfo->patch_archived_heap_embedded_pointers();
 // Close the mapinfo file
 mapinfo->close();
 if (PrintSharedArchiveAndExit) {
 if (PrintSharedDictionary) {

changeset 51491	187c84a5efe1
parent 51477	e77d7687c831
child 51554	5b0d86499960