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

equal deleted inserted replaced

-:595ab4f025d7
+:72d4e10305b9
 #include "precompiled.hpp"
 #include "jvm.h"
 #include "classfile/classLoader.inline.hpp"
 #include "classfile/classLoaderExt.hpp"
-#include "classfile/stringTable.hpp"
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionaryShared.hpp"
 #include "classfile/altHashing.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 " bytes, addr " INTPTR_FORMAT " file offset " SIZE_FORMAT_HEX_W(08),
 region, size, p2i(base), _file_offset);
 } else {
 si->_file_offset = _file_offset;
 }
-if (MetaspaceShared::is_heap_region(region)) {
+if (HeapShared::is_heap_region(region)) {
 assert((base - (char*)Universe::narrow_oop_base()) % HeapWordSize == 0, "Sanity");
 if (base != NULL) {
 si->_addr._offset = (intx)CompressedOops::encode_not_null((oop)base);
 } else {
 si->_addr._offset = 0;
 // Memory map a region in the address space.
 static const char* shared_region_name[] = { "MiscData", "ReadWrite", "ReadOnly", "MiscCode", "OptionalData",
 "String1", "String2", "OpenArchive1", "OpenArchive2" };
 char* FileMapInfo::map_region(int i, char** top_ret) {
-assert(!MetaspaceShared::is_heap_region(i), "sanity");
+assert(!HeapShared::is_heap_region(i), "sanity");
 CDSFileMapRegion* si = space_at(i);
 size_t used = si->_used;
 size_t alignment = os::vm_allocation_granularity();
 size_t size = align_up(used, alignment);
 char *requested_addr = region_addr(i);
 } else {
 return (address)HeapShared::decode_from_archive(offset_of_space(spc));
 }
 }
-static MemRegion *string_ranges = NULL;
+static MemRegion *closed_archive_heap_ranges = NULL;
 static MemRegion *open_archive_heap_ranges = NULL;
-static int num_string_ranges = 0;
+static int num_closed_archive_heap_ranges = 0;
 static int num_open_archive_heap_ranges = 0;
 #if INCLUDE_CDS_JAVA_HEAP
 bool FileMapInfo::has_heap_regions() {
-return (_header->_space[MetaspaceShared::first_string]._used > 0);
+return (_header->_space[MetaspaceShared::first_closed_archive_heap_region]._used > 0);
 }
 // Returns the address range of the archived heap regions computed using the
 // current oop encoding mode. This range may be different than the one seen at
 // dump time due to encoding mode differences. The result is used in determining
 // if/how these regions should be relocated at run time.
 MemRegion FileMapInfo::get_heap_regions_range_with_current_oop_encoding_mode() {
 address start = (address) max_uintx;
 address end   = NULL;
-for (int i = MetaspaceShared::first_string; i <= MetaspaceShared::last_valid_region; i++) {
+for (int i = MetaspaceShared::first_closed_archive_heap_region;
+i <= MetaspaceShared::last_valid_region;
+i++) {
 CDSFileMapRegion* si = space_at(i);
 size_t size = si->_used;
 if (size > 0) {
 address s = start_address_as_decoded_with_current_oop_encoding_mode(si);
 address e = s + size;
 assert(end != NULL, "must have at least one used heap region");
 return MemRegion((HeapWord*)start, (HeapWord*)end);
 }
 //
-// Map the shared string objects and open archive heap objects to the runtime
+// Map the closed and open archive heap objects to the runtime java heap.
-// java heap.
 //
-// The shared strings are mapped close to the end of the java heap top in
+// The shared objects are mapped at (or close to ) the java heap top in
-// closed archive regions. The mapped strings contain no out-going references
+// closed archive regions. The mapped objects contain no out-going
-// to any other java heap regions. GC does not write into the mapped shared strings.
+// references to any other java heap regions. GC does not write into the
+// mapped closed archive heap region.
 //
-// The open archive heap objects are mapped below the shared strings in
+// The open archive heap objects are mapped below the shared objects in
-// the runtime java heap. The mapped open archive heap data only contain
+// the runtime java heap. The mapped open archive heap data only contains
-// references to the shared strings and open archive objects initially.
+// references to the shared objects and open archive objects initially.
 // During runtime execution, out-going references to any other java heap
 // regions may be added. GC may mark and update references in the mapped
 // open archive objects.
 void FileMapInfo::map_heap_regions_impl() {
 if (!HeapShared::is_heap_object_archiving_allowed()) {
 }
 log_info(cds)("CDS heap data relocation delta = " INTX_FORMAT " bytes", delta);
 HeapShared::init_narrow_oop_decoding(narrow_oop_base() + delta, narrow_oop_shift());
-CDSFileMapRegion* si = space_at(MetaspaceShared::first_string);
+CDSFileMapRegion* si = space_at(MetaspaceShared::first_closed_archive_heap_region);
-address relocated_strings_bottom = start_address_as_decoded_from_archive(si);
+address relocated_closed_heap_region_bottom = start_address_as_decoded_from_archive(si);
-if (!is_aligned(relocated_strings_bottom, HeapRegion::GrainBytes)) {
+if (!is_aligned(relocated_closed_heap_region_bottom, HeapRegion::GrainBytes)) {
-// Align the bottom of the string regions at G1 region boundary. This will avoid
+// Align the bottom of the closed archive heap regions at G1 region boundary.
-// the situation where the highest open region and the lowest string region sharing
+// This will avoid the situation where the highest open region and the lowest
-// the same G1 region. Otherwise we will fail to map the open regions.
+// closed region sharing the same G1 region. Otherwise we will fail to map the
-size_t align = size_t(relocated_strings_bottom) % HeapRegion::GrainBytes;
+// open regions.
+size_t align = size_t(relocated_closed_heap_region_bottom) % HeapRegion::GrainBytes;
 delta -= align;
 log_info(cds)("CDS heap data need to be relocated lower by a further " SIZE_FORMAT
-" bytes to " INTX_FORMAT " to be aligned with HeapRegion::GrainBytes", align, delta);
+" bytes to " INTX_FORMAT " to be aligned with HeapRegion::GrainBytes",
+align, delta);
 HeapShared::init_narrow_oop_decoding(narrow_oop_base() + delta, narrow_oop_shift());
 _heap_pointers_need_patching = true;
-relocated_strings_bottom = start_address_as_decoded_from_archive(si);
+relocated_closed_heap_region_bottom = start_address_as_decoded_from_archive(si);
 }
-assert(is_aligned(relocated_strings_bottom, HeapRegion::GrainBytes), "must be");
+assert(is_aligned(relocated_closed_heap_region_bottom, HeapRegion::GrainBytes),
+"must be");
-// First, map string regions as closed archive heap regions.
-// GC does not write into the regions.
+// Map the closed_archive_heap regions, GC does not write into the regions.
-if (map_heap_data(&string_ranges,
+if (map_heap_data(&closed_archive_heap_ranges,
-MetaspaceShared::first_string,
+MetaspaceShared::first_closed_archive_heap_region,
-MetaspaceShared::max_strings,
+MetaspaceShared::max_closed_archive_heap_region,
-&num_string_ranges)) {
+&num_closed_archive_heap_ranges)) {
-StringTable::set_shared_string_mapped();
+HeapShared::set_closed_archive_heap_region_mapped();
 // Now, map open_archive heap regions, GC can write into the regions.
 if (map_heap_data(&open_archive_heap_ranges,
 MetaspaceShared::first_open_archive_heap_region,
 MetaspaceShared::max_open_archive_heap_region,
 void FileMapInfo::map_heap_regions() {
 if (has_heap_regions()) {
 map_heap_regions_impl();
 }
-if (!StringTable::shared_string_mapped()) {
+if (!HeapShared::closed_archive_heap_region_mapped()) {
-assert(string_ranges == NULL && num_string_ranges == 0, "sanity");
+assert(closed_archive_heap_ranges == NULL &&
+num_closed_archive_heap_ranges == 0, "sanity");
 }
 if (!HeapShared::open_archive_heap_region_mapped()) {
 assert(open_archive_heap_ranges == NULL && num_open_archive_heap_ranges == 0, "sanity");
 }
 void FileMapInfo::patch_archived_heap_embedded_pointers() {
 if (!_heap_pointers_need_patching) {
 return;
 }
-patch_archived_heap_embedded_pointers(string_ranges,
+patch_archived_heap_embedded_pointers(closed_archive_heap_ranges,
-num_string_ranges,
+num_closed_archive_heap_ranges,
-MetaspaceShared::first_string);
+MetaspaceShared::first_closed_archive_heap_region);
 patch_archived_heap_embedded_pointers(open_archive_heap_ranges,
 num_open_archive_heap_ranges,
 MetaspaceShared::first_open_archive_heap_region);
 }
 }
 // This internally allocates objects using SystemDictionary::Object_klass(), so it
 // must be called after the well-known classes are resolved.
 void FileMapInfo::fixup_mapped_heap_regions() {
-// If any string regions were found, call the fill routine to make them parseable.
+// If any closed regions were found, call the fill routine to make them parseable.
-// Note that string_ranges may be non-NULL even if no ranges were found.
+// Note that closed_archive_heap_ranges may be non-NULL even if no ranges were found.
-if (num_string_ranges != 0) {
+if (num_closed_archive_heap_ranges != 0) {
-assert(string_ranges != NULL, "Null string_ranges array with non-zero count");
+assert(closed_archive_heap_ranges != NULL,
-G1CollectedHeap::heap()->fill_archive_regions(string_ranges, num_string_ranges);
+"Null closed_archive_heap_ranges array with non-zero count");
+G1CollectedHeap::heap()->fill_archive_regions(closed_archive_heap_ranges,
+num_closed_archive_heap_ranges);
 }
 // do the same for mapped open archive heap regions
 if (num_open_archive_heap_ranges != 0) {
 assert(open_archive_heap_ranges != NULL, "NULL open_archive_heap_ranges array with non-zero count");
 size_t sz = space_at(i)->_used;
 if (sz == 0) {
 return true; // no data
 }
-if ((MetaspaceShared::is_string_region(i) &&
+if ((HeapShared::is_closed_archive_heap_region(i) &&
-!StringTable::shared_string_mapped()) ||
+!HeapShared::closed_archive_heap_region_mapped()) ||
-(MetaspaceShared::is_open_archive_heap_region(i) &&
+(HeapShared::is_open_archive_heap_region(i) &&
 !HeapShared::open_archive_heap_region_mapped())) {
 return true; // archived heap data is not mapped
 }
 const char* buf = region_addr(i);
 int crc = ClassLoader::crc32(0, buf, (jint)sz);
 }
 // Unmap a memory region in the address space.
 void FileMapInfo::unmap_region(int i) {
-assert(!MetaspaceShared::is_heap_region(i), "sanity");
+assert(!HeapShared::is_heap_region(i), "sanity");
 CDSFileMapRegion* si = space_at(i);
 size_t used = si->_used;
 size_t size = align_up(used, os::vm_allocation_granularity());
 if (used == 0) {
 return true;
 }
 char* FileMapInfo::region_addr(int idx) {
 CDSFileMapRegion* si = space_at(idx);
-if (MetaspaceShared::is_heap_region(idx)) {
+if (HeapShared::is_heap_region(idx)) {
 assert(DumpSharedSpaces, "The following doesn't work at runtime");
 return si->_used > 0 ?
 (char*)start_address_as_decoded_with_current_oop_encoding_mode(si) : NULL;
 } else {
 return si->_addr._base;
 // header data
 const char* prop = Arguments::get_property("java.system.class.loader");
 if (prop != NULL) {
 warning("Archived non-system classes are disabled because the "
 "java.system.class.loader property is specified (value = \"%s\"). "
-"To use archived non-system classes, this property must be not be set", prop);
+"To use archived non-system classes, this property must not be set", prop);
 _has_platform_or_app_classes = false;
 }
 // For backwards compatibility, we don't check the verification setting
 // if the archive only contains system classes.
 FileMapInfo *map_info = FileMapInfo::current_info();
 if (map_info) {
 map_info->fail_continue("%s", msg);
 for (int i = 0; i < MetaspaceShared::num_non_heap_spaces; i++) {
-if (!MetaspaceShared::is_heap_region(i)) {
+if (!HeapShared::is_heap_region(i)) {
 char *addr = map_info->region_addr(i);
 if (addr != NULL) {
 map_info->unmap_region(i);
 map_info->space_at(i)->_addr._base = NULL;
 }
 }
 // Dealloc the archive heap regions only without unmapping. The regions are part
 // of the java heap. Unmapping of the heap regions are managed by GC.
 map_info->dealloc_archive_heap_regions(open_archive_heap_ranges,
 num_open_archive_heap_ranges);
-map_info->dealloc_archive_heap_regions(string_ranges, num_string_ranges);
+map_info->dealloc_archive_heap_regions(closed_archive_heap_ranges,
+num_closed_archive_heap_ranges);
 } else if (DumpSharedSpaces) {
 fail_stop("%s", msg);
 }
 }

changeset 52402	72d4e10305b9
parent 52319	625f6c742392
child 52514	f4e3900c8d08